@xiawan-play/steam-tools-mcp 0.1.1 → 0.2.0

package/dist/server.js

@@ -9882,11 +9882,11 @@ function parseAppIdCollection(value) {
 function getNestedValue(value, ...keys) {
   let current = value;
   for (const key of keys) {
-    const record3 = asRecord(current);
-    if (!record3) {
+    const record2 = asRecord(current);
+    if (!record2) {
       return void 0;
     }
-    current = record3[key];
+    current = record2[key];
   }
   return current;
 }
@@ -9948,119 +9948,16 @@ function chunkStrings(values, chunkSize) {
   }
   return chunks;
 }
-function normalizeAppCatalogType(record3) {
-  if (!record3) {
+function normalizeAppCatalogType(record2) {
+  if (!record2) {
     return void 0;
   }
-  return getStringValue(record3.type) ?? getStringValue(record3.app_type) ?? getStringValue(record3.app_type_string);
+  return getStringValue(record2.type) ?? getStringValue(record2.app_type) ?? getStringValue(record2.app_type_string);
 }
 
 // src/lib/steam-client.ts
 import * as z from "zod/v4";
 var DEFAULT_TIMEOUT_MS = 3e4;
-var NUMERIC_PARAM_TYPES = [
-  "int32",
-  "int64",
-  "uint8",
-  "uint16",
-  "uint32",
-  "uint64",
-  "float",
-  "double",
-  "steamid",
-  "steamid64",
-  "gameid",
-  "appid",
-  "publishedfileid",
-  "eresult"
-];
-function createToolDescription(method) {
-  const auth = method.requiresPublisherKey ? "\u9700\u8981 Steam publisher key\uFF08\u53D1\u884C\u5546\u5BC6\u94A5\uFF09\u3002" : method.requiresUserKey ? "\u9700\u8981 Steam user Web API key\uFF08\u7528\u6237\u5BC6\u94A5\uFF09\u3002" : "\u6309\u5F53\u524D\u6587\u6863\u53EF\u533F\u540D\u8C03\u7528\uFF0C\u4E0D\u9700\u8981 key\u3002";
-  const service = method.serviceInterface ? "\u8FD9\u662F Steam Service Interface\uFF0C\u8BF7\u6C42\u4F1A\u4EE5 input_json \u65B9\u5F0F\u53D1\u9001\u3002" : "\u8FD9\u662F\u6807\u51C6 Steam Web API \u63A5\u53E3\uFF0C\u4F7F\u7528\u666E\u901A\u53C2\u6570\u98CE\u683C\u8C03\u7528\u3002";
-  const params = method.parameters.length ? `\u53C2\u6570\u6982\u89C8\uFF1A${method.parameters.map(
-    (param) => `${param.inputName}${param.required && param.originalName !== "key" ? "*" : ""}`
-  ).join(", ")}\u3002` : "\u53C2\u6570\u6982\u89C8\uFF1A\u65E0\u53C2\u6570\u3002";
-  const officialDescription = method.description?.trim() ? `\u5B98\u65B9\u82F1\u6587\u8BF4\u660E\uFF1A${method.description}` : "\u5B98\u65B9\u82F1\u6587\u8BF4\u660E\uFF1A\u65E0\u3002";
-  return `${officialDescription} \u9274\u6743\u8981\u6C42\uFF1A${auth} \u8C03\u7528\u65B9\u5F0F\uFF1A${service} ${params}`;
-}
-function createParamSchema(param, options) {
-  let schema;
-  const normalizedType = param.type.toLowerCase();
-  if (normalizedType === "bool") {
-    schema = z.union([
-      z.boolean(),
-      z.literal("true"),
-      z.literal("false"),
-      z.literal("1"),
-      z.literal("0"),
-      z.literal(1),
-      z.literal(0)
-    ]);
-  } else if (normalizedType === "string" || normalizedType === "rawbinary") {
-    schema = z.string();
-  } else if (normalizedType === "{message}" || normalizedType.includes("message")) {
-    schema = z.union([z.record(z.string(), z.any()), z.array(z.any())]);
-  } else if (normalizedType.endsWith("[]")) {
-    const itemType = normalizedType.slice(0, -2);
-    schema = z.array(createScalarSchema(itemType));
-  } else if (NUMERIC_PARAM_TYPES.some((type) => normalizedType.includes(type))) {
-    schema = createScalarSchema(normalizedType);
-  } else {
-    schema = z.union([
-      z.string(),
-      z.number(),
-      z.boolean(),
-      z.record(z.string(), z.any()),
-      z.array(z.any())
-    ]);
-  }
-  if (param.isArray && !normalizedType.endsWith("[]")) {
-    schema = z.union([schema, z.array(schema)]);
-  }
-  if (options?.allowDefaultSteamId) {
-    schema = schema.optional();
-  } else if (param.originalName === "key") {
-    schema = schema.optional();
-  } else if (!param.required) {
-    schema = schema.optional();
-  }
-  const details = [
-    `Steam \u53C2\u6570\u540D\uFF1A${param.originalName}\u3002`,
-    `\u7C7B\u578B\uFF1A${param.type}\u3002`,
-    param.required || options?.allowDefaultSteamId ? options?.allowDefaultSteamId ? "\u9ED8\u8BA4\u60C5\u51B5\u4E0B\u5FC5\u586B\uFF1B\u5982\u679C\u5DF2\u7ECF\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u53EF\u4EE5\u7701\u7565\u3002" : "\u662F\u5426\u5FC5\u586B\uFF1A\u662F\u3002" : "\u662F\u5426\u5FC5\u586B\uFF1A\u5426\u3002",
-    param.description ? `\u5B98\u65B9\u82F1\u6587\u8BF4\u660E\uFF1A${param.description}` : "\u5B98\u65B9\u82F1\u6587\u8BF4\u660E\uFF1A\u65E0\u3002"
-  ].filter(Boolean).join(" ");
-  return schema.describe(details);
-}
-function createScalarSchema(type) {
-  if (type === "bool") {
-    return z.union([
-      z.boolean(),
-      z.literal("true"),
-      z.literal("false"),
-      z.literal("1"),
-      z.literal("0"),
-      z.literal(1),
-      z.literal(0)
-    ]);
-  }
-  if (type === "string" || type === "rawbinary") {
-    return z.string();
-  }
-  return z.union([z.string(), z.number()]);
-}
-function buildInputSchema(method, options) {
-  if (!method.parameters.length) {
-    return void 0;
-  }
-  const schemaEntries = method.parameters.map((param) => [
-    param.inputName,
-    createParamSchema(param, {
-      allowDefaultSteamId: Boolean(options?.defaultSteamId) && (param.originalName === "steamid" || param.originalName === "steamids")
-    })
-  ]);
-  return Object.fromEntries(schemaEntries);
-}
 async function callSteamApi(method, args, options) {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const endpoint = resolveEndpointUrl(method.url, options?.baseUrl);
@@ -10203,6 +10100,9 @@ function redactUrl(url) {
   return `${url.origin}${url.pathname}`;
 }
 
+// src/services/base.ts
+import { load } from "cheerio";
+
 // src/normalizers/games.ts
 function normalizeRecentlyPlayedGames(data) {
   const response = asRecord(getNestedValue(data, "response"));
@@ -10303,18 +10203,18 @@ function parseAppCatalogPage(data) {
   ];
   const entries = [];
   for (const entry of rawEntries) {
-    const record3 = asRecord(entry);
-    const appid = normalizeScalarInput(record3?.appid);
-    const name = getStringValue(record3?.name);
+    const record2 = asRecord(entry);
+    const appid = normalizeScalarInput(record2?.appid);
+    const name = getStringValue(record2?.name);
     if (!appid || !name) {
       continue;
     }
     entries.push({
       appid,
       name,
-      type: normalizeAppCatalogType(record3),
-      lastModified: toNumber(record3?.last_modified),
-      priceChangeNumber: toNumber(record3?.price_change_number)
+      type: normalizeAppCatalogType(record2),
+      lastModified: toNumber(record2?.last_modified),
+      priceChangeNumber: toNumber(record2?.price_change_number)
     });
   }
   const lastAppId = normalizeScalarInput(getNestedValue(data, "response", "last_appid")) ?? entries.at(-1)?.appid;
@@ -10686,6 +10586,8 @@ function createSteamBaseRuntime(spec2, config) {
     spec2.methods.map((method) => [method.toolName, method])
   );
   let appCatalogCache = null;
+  const localizedAppNameCache = /* @__PURE__ */ new Map();
+  const storeSearchCache = /* @__PURE__ */ new Map();
   async function invokeSteamMethod(method, args, apiKeyOverride) {
     if (method.interfaceName === "ISteamApps" && method.methodName === "GetAppList") {
       throw new Error(
@@ -10830,10 +10732,10 @@ function createSteamBaseRuntime(spec2, config) {
         apiKey
       );
       for (const player of getNestedArray(result.data, "response", "players")) {
-        const record3 = normalizePlayerSummary({ response: { players: [player] } });
+        const record2 = normalizePlayerSummary({ response: { players: [player] } });
         const steamid = getStringValue(asRecord(player)?.steamid);
-        if (steamid && record3) {
-          summaryMap.set(steamid, record3);
+        if (steamid && record2) {
+          summaryMap.set(steamid, record2);
         }
       }
     }
@@ -10849,10 +10751,10 @@ function createSteamBaseRuntime(spec2, config) {
         apiKey
       );
       for (const player of getNestedArray(result.data, "players")) {
-        const record3 = normalizePlayerBan({ players: [player] });
+        const record2 = normalizePlayerBan({ players: [player] });
         const steamid = getStringValue(asRecord(player)?.SteamId);
-        if (steamid && record3) {
-          banMap.set(steamid, record3);
+        if (steamid && record2) {
+          banMap.set(steamid, record2);
         }
       }
     }
@@ -10957,11 +10859,186 @@ function createSteamBaseRuntime(spec2, config) {
     };
     return appCatalogCache;
   }
+  async function fetchStoreSearchCandidates(query, locale, limit) {
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery) {
+      return [];
+    }
+    const cacheKey = `${locale}:${normalizedQuery.toLowerCase()}`;
+    const cached = storeSearchCache.get(cacheKey);
+    const now = Date.now();
+    if (cached && cached.expiresAt > now) {
+      return cached.results.slice(0, limit);
+    }
+    const results = [];
+    const seenAppIds = /* @__PURE__ */ new Set();
+    const suggestUrl = new URL("https://store.steampowered.com/search/suggest");
+    suggestUrl.searchParams.set("term", normalizedQuery);
+    suggestUrl.searchParams.set("f", "games");
+    suggestUrl.searchParams.set("cc", "CN");
+    suggestUrl.searchParams.set("l", locale);
+    suggestUrl.searchParams.set("realm", "1");
+    const suggestText = await fetchTextResponse(suggestUrl, 3500);
+    const suggest$ = load(`<div>${suggestText}</div>`);
+    suggest$("a").each((index, element) => {
+      const anchor = suggest$(element);
+      const href = anchor.attr("href") ?? "";
+      const hrefMatch = href.match(/\/app\/(\d+)/);
+      const appid = normalizeScalarInput(anchor.attr("data-ds-appid")) ?? normalizeScalarInput(anchor.attr("data-appid")) ?? normalizeScalarInput(hrefMatch?.[1]);
+      const localizedName = anchor.find(".match_name").first().text().trim() || anchor.find(".match_title").first().text().trim() || anchor.text().replace(/\s+/g, " ").trim();
+      if (!appid || !localizedName || seenAppIds.has(appid)) {
+        return;
+      }
+      seenAppIds.add(appid);
+      results.push({
+        appid,
+        localizedName,
+        displayName: localizedName,
+        score: 2e3 - index,
+        matchType: "localizedQuery",
+        source: "storeSearch"
+      });
+    });
+    if (results.length === 0) {
+      const searchUrl = new URL("https://store.steampowered.com/search/");
+      searchUrl.searchParams.set("term", normalizedQuery);
+      searchUrl.searchParams.set("ignore_preferences", "1");
+      searchUrl.searchParams.set("ndl", "1");
+      searchUrl.searchParams.set("cc", "CN");
+      searchUrl.searchParams.set("l", locale);
+      const searchText = await fetchTextResponse(searchUrl, 3500);
+      const search$ = load(searchText);
+      search$("a.search_result_row").each((index, element) => {
+        const anchor = search$(element);
+        const href = anchor.attr("href") ?? "";
+        const hrefMatch = href.match(/\/app\/(\d+)/);
+        const appid = normalizeScalarInput(anchor.attr("data-ds-appid")) ?? normalizeScalarInput(anchor.attr("data-appid")) ?? normalizeScalarInput(hrefMatch?.[1]);
+        const title = anchor.find(".title").first().text().trim();
+        if (!appid || !title || seenAppIds.has(appid)) {
+          return;
+        }
+        seenAppIds.add(appid);
+        results.push({
+          appid,
+          name: title,
+          displayName: title,
+          score: 1800 - index,
+          matchType: "storeSearchPage",
+          source: "storeSearch"
+        });
+      });
+    }
+    storeSearchCache.set(cacheKey, {
+      expiresAt: now + 60 * 60 * 1e3,
+      results
+    });
+    return results.slice(0, limit);
+  }
+  async function fetchLocalizedStoreAppName(appid, locale) {
+    const cacheKey = `${appid}:${locale}`;
+    const cached = localizedAppNameCache.get(cacheKey);
+    const now = Date.now();
+    if (cached && cached.expiresAt > now) {
+      return cached.value;
+    }
+    const url = new URL("https://store.steampowered.com/api/appdetails");
+    url.searchParams.set("appids", appid);
+    url.searchParams.set("l", locale);
+    url.searchParams.set("cc", "cn");
+    const payload = await fetchJsonResponse(url, 3500);
+    const entry = asRecord(getNestedValue(payload, appid));
+    const data = asRecord(entry?.data);
+    const localizedName = getStringValue(data?.name);
+    const value = {
+      localizedName,
+      source: localizedName ? "storeAppDetails" : "fallback",
+      locale
+    };
+    localizedAppNameCache.set(cacheKey, {
+      expiresAt: now + 24 * 60 * 60 * 1e3,
+      value
+    });
+    return value;
+  }
+  function mergeResolutionCandidates(catalogCandidates, localizedCandidates, catalogByAppId) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const candidate of localizedCandidates) {
+      merged.set(candidate.appid, candidate);
+    }
+    for (const candidate of catalogCandidates) {
+      const appid = normalizeScalarInput(candidate.appid);
+      if (!appid) {
+        continue;
+      }
+      const existing = merged.get(appid);
+      const catalogEntry = catalogByAppId.get(appid);
+      const name = getStringValue(candidate.name) ?? catalogEntry?.name;
+      const type = getStringValue(candidate.type) ?? catalogEntry?.type;
+      const score = Number(candidate.score) || 0;
+      const matchType = getStringValue(candidate.matchType) ?? "catalog";
+      if (existing) {
+        merged.set(appid, {
+          ...existing,
+          name: existing.name ?? name,
+          type: existing.type ?? type,
+          displayName: existing.displayName || existing.localizedName || name || appid,
+          score: Math.max(existing.score, score)
+        });
+        continue;
+      }
+      merged.set(appid, {
+        appid,
+        name,
+        type,
+        displayName: name ?? appid,
+        score,
+        matchType,
+        source: "catalog"
+      });
+    }
+    return [...merged.values()].sort((left, right) => {
+      if (right.score !== left.score) {
+        return right.score - left.score;
+      }
+      return left.displayName.localeCompare(right.displayName);
+    });
+  }
+  async function buildAppTarget(input) {
+    const locale = normalizeLocale(input.locale);
+    const name = input.app?.name ?? input.candidate?.name;
+    let localizedName = input.candidate?.localizedName;
+    let localizationSource = localizedName ? "storeSearch" : name ? "catalog" : "fallback";
+    if (!localizedName && input.preferLocalizedName && locale) {
+      try {
+        const localized = await fetchLocalizedStoreAppName(input.appid, locale);
+        if (localized.localizedName) {
+          localizedName = localized.localizedName;
+          localizationSource = localized.source;
+        }
+      } catch (error) {
+        input.warnings.push(
+          `Localized app name lookup failed for appid ${input.appid}: ${getErrorMessage(error)}`
+        );
+      }
+    }
+    return {
+      appid: input.appid,
+      query: input.query,
+      name,
+      localizedName,
+      displayName: localizedName ?? name ?? input.appid,
+      type: input.app?.type ?? input.candidate?.type,
+      resolvedFrom: input.resolvedFrom,
+      localizationSource,
+      locale
+    };
+  }
   async function resolveAppSelection(input) {
     const explicitAppId = normalizeScalarInput(input.appid);
     const queryValue = normalizeScalarInput(input.query);
     const warnings = [];
     const catalogApiKey = input.key ?? config.apiKey;
+    const locale = normalizeLocale(input.locale) ?? (queryValue && containsNonAscii(queryValue) ? "schinese" : void 0);
     const directAppId = explicitAppId ?? (queryValue && /^\d+$/.test(queryValue) ? queryValue : void 0);
     if (directAppId) {
       let app = null;
@@ -10973,21 +11050,35 @@ function createSteamBaseRuntime(spec2, config) {
           warnings.push(`App catalog lookup failed: ${getErrorMessage(error)}`);
         }
       }
+      const candidates2 = app ? [
+        {
+          appid: app.appid,
+          name: app.name,
+          displayName: app.name,
+          type: app.type,
+          score: 1e3,
+          matchType: "appid",
+          source: "catalog"
+        }
+      ] : [];
+      const target2 = await buildAppTarget({
+        appid: directAppId,
+        app,
+        query: queryValue,
+        resolvedFrom: "appid",
+        locale,
+        preferLocalizedName: input.preferLocalizedName ?? false,
+        warnings,
+        candidate: candidates2[0] ?? null
+      });
       return {
         appid: directAppId,
         app,
         query: queryValue,
         resolvedFrom: "appid",
-        candidates: app ? [
-          {
-            appid: app.appid,
-            name: app.name,
-            type: app.type,
-            score: 1e3,
-            matchType: "appid"
-          }
-        ] : [],
-        warnings
+        candidates: candidates2,
+        warnings,
+        target: target2
       };
     }
     if (!queryValue) {
@@ -11001,11 +11092,30 @@ function createSteamBaseRuntime(spec2, config) {
       includeVideos: input.includeVideos ?? false,
       includeHardware: input.includeHardware ?? false
     });
-    const candidates = searchAppCatalog(filteredEntries, queryValue, {
+    const catalogCandidates = searchAppCatalog(filteredEntries, queryValue, {
       limit: input.limit,
       exactOnly: false
     });
-    const bestCandidate = asRecord(candidates[0]);
+    let localizedCandidates = [];
+    if (containsNonAscii(queryValue) || catalogCandidates.length === 0) {
+      try {
+        localizedCandidates = await fetchStoreSearchCandidates(
+          queryValue,
+          locale ?? "schinese",
+          input.limit
+        );
+      } catch (error) {
+        warnings.push(
+          `Localized app search failed for '${queryValue}': ${getErrorMessage(error)}`
+        );
+      }
+    }
+    const candidates = mergeResolutionCandidates(
+      catalogCandidates,
+      localizedCandidates,
+      catalog.byAppId
+    ).slice(0, input.limit);
+    const bestCandidate = candidates[0];
     if (!bestCandidate) {
       throw new Error(`No Steam app matched query '${queryValue}'.`);
     }
@@ -11013,13 +11123,24 @@ function createSteamBaseRuntime(spec2, config) {
     if (!bestAppId) {
       throw new Error(`No Steam app matched query '${queryValue}'.`);
     }
+    const target = await buildAppTarget({
+      appid: bestAppId,
+      app: catalog.byAppId.get(bestAppId) ?? null,
+      query: queryValue,
+      resolvedFrom: "query",
+      locale,
+      preferLocalizedName: input.preferLocalizedName ?? false,
+      warnings,
+      candidate: bestCandidate
+    });
     return {
       appid: bestAppId,
       app: catalog.byAppId.get(bestAppId) ?? null,
       query: queryValue,
       resolvedFrom: "query",
       candidates,
-      warnings
+      warnings,
+      target
     };
   }
   function applyDefaultSteamIdentityArgs(method, args) {
@@ -11094,6 +11215,8 @@ function createSteamBaseRuntime(spec2, config) {
     fetchTopOwnedAppIds,
     fetchOwnedGamesContext,
     fetchAppCatalog,
+    fetchLocalizedStoreAppName,
+    fetchStoreSearchCandidates,
     resolveAppSelection,
     resolveMethod,
     mapRawParams,
@@ -11107,6 +11230,36 @@ function formatSteamCallError(response) {
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function containsNonAscii(value) {
+  return /[^\u0000-\u007f]/.test(value);
+}
+function normalizeLocale(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed.toLowerCase() : void 0;
+}
+async function fetchTextResponse(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(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"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+    return await response.text();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchJsonResponse(url, timeoutMs) {
+  const text = await fetchTextResponse(url, timeoutMs);
+  return JSON.parse(text);
+}
 
 // src/tools/apps.ts
 import * as z2 from "zod/v4";
@@ -11359,18 +11512,32 @@ async function buildPlayerProfileOverviewData(runtime2, input) {
   const badges = normalizeBadgeSummary(badgesCall.data);
   const recentGames = normalizeRecentlyPlayedGames(recentGamesCall?.data);
   const level = toNumber(getNestedValue(steamLevelCall.data, "response", "player_level")) ?? toNumber(getNestedValue(steamLevelCall.data, "player_level"));
+  const recentItems = input.includeRecentlyPlayed && Array.isArray(recentGames?.games) ? recentGames?.games : [];
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: playerSummary,
+    target: {
+      player: {
+        steamid: identity.steamid,
+        resolvedFrom: identity.resolvedFrom,
+        vanityUrl: identity.vanityUrl
+      }
+    },
+    summary: {
       level,
+      badgeCount: toNumber(badges?.badgeCount) ?? 0,
+      recentlyPlayedCount: recentItems.length,
+      hasVacBan: toBoolean(banSummary?.vacBanned) ?? false,
+      hasGameBan: (toNumber(banSummary?.numberOfGameBans) ?? 0) > 0
+    },
+    sections: {
+      profile: playerSummary,
       bans: banSummary,
       badges,
-      recentlyPlayed: input.includeRecentlyPlayed ? recentGames : void 0
+      recentlyPlayed: input.includeRecentlyPlayed ? {
+        totalCount: toNumber(recentGames?.totalCount) ?? recentItems.length,
+        items: recentItems
+      } : void 0
     },
     warnings: runtime2.collectWarnings([
       playerSummaryCall,
@@ -11422,23 +11589,32 @@ async function buildLibraryOverviewData(runtime2, input) {
     (sum, game) => sum + (toNumber(game.playtimeForeverMinutes) ?? 0),
     0
   );
+  const recentItems = input.includeRecentGames && Array.isArray(recentGames?.games) ? recentGames.games : [];
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: playerSummary
+    target: {
+      player: {
+        steamid: identity.steamid,
+        resolvedFrom: identity.resolvedFrom,
+        vanityUrl: identity.vanityUrl
+      }
     },
-    library: {
+    summary: {
       gameCount: ownedGames.gameCount,
       totalPlaytimeMinutes,
       totalPlaytimeHours: roundTo(totalPlaytimeMinutes / 60, 2),
+      recentGameCount: recentItems.length,
       includeAppInfo: input.includeAppInfo,
-      includePlayedFreeGames: input.includePlayedFreeGames,
-      topGamesByPlaytime,
-      recentGames: input.includeRecentGames ? recentGames : void 0
+      includePlayedFreeGames: input.includePlayedFreeGames
+    },
+    items: topGamesByPlaytime,
+    sections: {
+      profile: playerSummary,
+      recentlyPlayed: input.includeRecentGames ? {
+        totalCount: toNumber(recentGames?.totalCount) ?? recentItems.length,
+        items: recentItems
+      } : void 0
     },
     warnings: runtime2.collectWarnings([
       ownedGamesCall,
@@ -11447,20 +11623,29 @@ async function buildLibraryOverviewData(runtime2, input) {
     ])
   };
 }
-async function buildAchievementOverviewData(runtime2, input) {
+async function buildPlayerGameAchievementsData(runtime2, input) {
   const apiKey = runtime2.requireSteamApiKey(input.toolName, input.key);
   const identity = await runtime2.resolvePlayerIdentity(
     { steamid: input.steamid, vanityUrl: input.vanityUrl },
     apiKey
   );
-  const appIdValue = normalizeScalarInput(input.appid);
+  const resolved = await runtime2.resolveAppSelection({
+    toolName: input.toolName,
+    appid: input.appid,
+    query: input.query,
+    key: apiKey,
+    limit: 5,
+    forceRefresh: false,
+    locale: input.language,
+    preferLocalizedName: Boolean(input.query) || Boolean(input.language)
+  });
   const requests = [
     runtime2.safeInvokeKnownMethod(
       "ISteamUserStats",
       "GetPlayerAchievements",
       {
         steamid: identity.steamid,
-        appid: appIdValue,
+        appid: resolved.appid,
         l: input.language
       },
       apiKey
@@ -11469,7 +11654,7 @@ async function buildAchievementOverviewData(runtime2, input) {
       "ISteamUserStats",
       "GetSchemaForGame",
       {
-        appid: appIdValue,
+        appid: resolved.appid,
         l: input.language
       },
       apiKey
@@ -11479,7 +11664,7 @@ async function buildAchievementOverviewData(runtime2, input) {
       "GetUserStatsForGame",
       {
         steamid: identity.steamid,
-        appid: appIdValue
+        appid: resolved.appid
       },
       apiKey
     ) : Promise.resolve(null),
@@ -11487,7 +11672,7 @@ async function buildAchievementOverviewData(runtime2, input) {
       "ISteamUserStats",
       "GetGlobalAchievementPercentagesForApp",
       {
-        gameid: appIdValue
+        gameid: resolved.appid
       },
       void 0
     )
@@ -11512,47 +11697,70 @@ async function buildAchievementOverviewData(runtime2, input) {
   ).slice(0, input.recentUnlockedCount);
   const totalAchievements = mergedAchievements.length || normalizeAchievementSchema(schemaCall.data).length;
   const unlockedCount = unlockedAchievements.length;
+  const schemaGameName = getStringValue(getNestedValue(schemaCall.data, "game", "gameName"));
+  const gameName = getStringValue(
+    getNestedValue(playerAchievementsCall.data, "playerstats", "gameName")
+  ) ?? schemaGameName ?? getStringValue(getNestedValue(playerStatsCall?.data, "playerstats", "gameName"));
+  const appTarget = schemaGameName && schemaGameName !== resolved.target.displayName ? {
+    ...resolved.target,
+    localizedName: schemaGameName,
+    displayName: schemaGameName,
+    localizationSource: "schema",
+    locale: input.language?.trim().toLowerCase() ?? resolved.target.locale
+  } : {
+    ...resolved.target,
+    name: resolved.target.name ?? gameName,
+    displayName: resolved.target.displayName ?? gameName ?? resolved.target.appid
+  };
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl
-    },
-    game: {
-      appid: appIdValue,
-      gameName: getStringValue(
-        getNestedValue(playerAchievementsCall.data, "playerstats", "gameName")
-      ) ?? getStringValue(getNestedValue(schemaCall.data, "game", "gameName")) ?? getStringValue(
-        getNestedValue(playerStatsCall?.data, "playerstats", "gameName")
-      )
+    target: {
+      player: {
+        steamid: identity.steamid,
+        resolvedFrom: identity.resolvedFrom,
+        vanityUrl: identity.vanityUrl
+      },
+      app: appTarget
     },
-    achievementSummary: {
+    summary: {
       totalAchievements,
       unlockedCount,
       lockedCount: Math.max(totalAchievements - unlockedCount, 0),
       completionRate: totalAchievements > 0 ? roundTo(unlockedCount / totalAchievements * 100, 2) : 0,
-      recentlyUnlocked
+      recentlyUnlockedCount: recentlyUnlocked.length
     },
-    achievements: mergedAchievements,
-    stats: input.includeStats ? playerStats : void 0,
-    warnings: runtime2.collectWarnings([
-      playerAchievementsCall,
-      schemaCall,
-      playerStatsCall,
-      globalPercentagesCall
-    ])
+    items: mergedAchievements,
+    sections: {
+      recentlyUnlocked,
+      stats: input.includeStats ? playerStats : void 0
+    },
+    warnings: [
+      ...resolved.warnings,
+      ...runtime2.collectWarnings([
+        playerAchievementsCall,
+        schemaCall,
+        playerStatsCall,
+        globalPercentagesCall
+      ])
+    ]
   };
 }
-async function buildNewsOverviewData(runtime2, input) {
-  const appIdValue = normalizeScalarInput(input.appid);
+async function buildAppNewsData(runtime2, input) {
+  const resolved = await runtime2.resolveAppSelection({
+    toolName: input.toolName,
+    appid: input.appid,
+    query: input.query,
+    limit: 5,
+    forceRefresh: false,
+    preferLocalizedName: Boolean(input.query)
+  });
   const feedValue = Array.isArray(input.feeds) ? input.feeds.join(",") : input.feeds;
   const newsCall = await runtime2.safeInvokeKnownMethod(
     "ISteamNews",
     "GetNewsForApp",
     {
-      appid: appIdValue,
+      appid: resolved.appid,
       count: input.count,
       maxlength: input.maxlength,
       enddate: input.enddate,
@@ -11563,7 +11771,7 @@ async function buildNewsOverviewData(runtime2, input) {
   const playerCountCall = input.includePlayerCount ? await runtime2.safeInvokeKnownMethod(
     "ISteamUserStats",
     "GetNumberOfCurrentPlayers",
-    { appid: appIdValue },
+    { appid: resolved.appid },
     void 0
   ) : null;
   const newsItems = normalizeNewsItems(newsCall.data);
@@ -11571,16 +11779,19 @@ async function buildNewsOverviewData(runtime2, input) {
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    game: {
-      appid: appIdValue,
-      currentPlayers
+    target: {
+      app: resolved.target
     },
-    news: {
+    summary: {
       requestedCount: input.count,
       returnedCount: newsItems.length,
-      items: newsItems
+      currentPlayers
     },
-    warnings: runtime2.collectWarnings([newsCall, playerCountCall])
+    items: newsItems,
+    warnings: [
+      ...resolved.warnings,
+      ...runtime2.collectWarnings([newsCall, playerCountCall])
+    ]
   };
 }
 
@@ -11594,27 +11805,44 @@ async function buildAppSearchData(runtime2, input) {
     includeVideos: input.includeVideos,
     includeHardware: input.includeHardware
   });
-  const results = searchAppCatalog(filteredEntries, input.query, {
+  const catalogResults = searchAppCatalog(filteredEntries, input.query, {
     limit: input.limit,
     exactOnly: input.exactOnly
   });
+  let localizedResults = [];
+  if (/[^\u0000-\u007f]/.test(input.query) || catalogResults.length === 0) {
+    try {
+      localizedResults = await runtime2.fetchStoreSearchCandidates(
+        input.query,
+        "schinese",
+        input.limit
+      );
+    } catch {
+      localizedResults = [];
+    }
+  }
+  const items = [...localizedResults, ...catalogResults].slice(0, input.limit);
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    query: input.query,
-    resultCount: results.length,
-    catalog: {
-      totalEntries: catalog.entries.length,
+    target: {
+      query: input.query
+    },
+    summary: {
+      resultCount: items.length,
+      totalCatalogEntries: catalog.entries.length,
       searchableEntries: filteredEntries.length,
       cacheExpiresAt: new Date(catalog.expiresAt).toISOString(),
       filters: {
         includeDlc: input.includeDlc,
         includeSoftware: input.includeSoftware,
         includeVideos: input.includeVideos,
-        includeHardware: input.includeHardware
+        includeHardware: input.includeHardware,
+        exactOnly: input.exactOnly
       }
     },
-    results
+    items,
+    warnings: []
   };
 }
 async function buildAppResolveData(runtime2, input) {
@@ -11628,19 +11856,20 @@ async function buildAppResolveData(runtime2, input) {
       includeDlc: input.includeDlc,
       includeSoftware: input.includeSoftware,
       includeVideos: input.includeVideos,
-      includeHardware: input.includeHardware
+      includeHardware: input.includeHardware,
+      preferLocalizedName: true
     });
     return {
       ok: true,
       requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      query: normalizeScalarInput(input.query),
-      resolved: {
-        appid: resolved.appid,
-        name: resolved.app?.name,
-        type: resolved.app?.type,
-        resolvedFrom: resolved.resolvedFrom
+      target: {
+        query: normalizeScalarInput(input.query),
+        app: resolved.target
       },
-      candidates: resolved.candidates,
+      summary: {
+        candidateCount: resolved.candidates.length
+      },
+      items: resolved.candidates,
       warnings: resolved.warnings
     };
   } catch (error) {
@@ -11651,9 +11880,14 @@ async function buildAppResolveData(runtime2, input) {
     return {
       ok: false,
       requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      query: normalizeScalarInput(input.query),
+      target: {
+        query: normalizeScalarInput(input.query)
+      },
+      summary: {
+        candidateCount: 0
+      },
+      items: [],
       note: message,
-      candidates: [],
       warnings: []
     };
   }
@@ -11665,7 +11899,9 @@ async function buildGlobalAchievementOverviewData(runtime2, input) {
     query: input.query,
     key: input.key,
     limit: 5,
-    forceRefresh: false
+    forceRefresh: false,
+    locale: input.language,
+    preferLocalizedName: Boolean(input.query) || Boolean(input.language)
   });
   const apiKey = input.key ?? runtime2.config.apiKey;
   const warnings = [...resolved.warnings];
@@ -11707,25 +11943,31 @@ async function buildGlobalAchievementOverviewData(runtime2, input) {
     ) / achievementsWithPercent.length,
     2
   ) : null;
+  const schemaGameName = asRecord(getNestedValue(schemaCall?.data, "game"));
+  const appTarget = schemaGameName && normalizeScalarInput(schemaGameName.gameName) ? {
+    ...resolved.target,
+    localizedName: normalizeScalarInput(schemaGameName.gameName) ?? resolved.target.localizedName,
+    displayName: normalizeScalarInput(schemaGameName.gameName) ?? resolved.target.displayName,
+    localizationSource: "schema",
+    locale: input.language?.trim().toLowerCase() ?? resolved.target.locale
+  } : resolved.target;
   return {
     ok: globalCall.ok,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    app: {
-      appid: resolved.appid,
-      name: resolved.app?.name,
-      type: resolved.app?.type,
-      resolvedFrom: resolved.resolvedFrom,
-      query: resolved.query
+    target: {
+      app: appTarget
     },
-    achievementSummary: {
+    summary: {
       totalAchievements: achievements.length,
       achievementsWithGlobalPercent: achievementsWithPercent.length,
       schemaEnriched: Boolean(schemaCall?.ok),
       averageUnlockRate
     },
-    rarestAchievements: achievementsWithPercent.slice(0, input.topCount),
-    mostCommonAchievements: [...achievementsWithPercent].reverse().slice(0, input.topCount),
-    achievements,
+    items: achievements,
+    sections: {
+      rarest: achievementsWithPercent.slice(0, input.topCount),
+      mostCommon: [...achievementsWithPercent].reverse().slice(0, input.topCount)
+    },
     warnings: [...warnings, ...runtime2.collectWarnings([globalCall, schemaCall])]
   };
 }
@@ -11736,10 +11978,12 @@ async function buildAppSnapshotData(runtime2, input) {
     query: input.query,
     key: input.key,
     limit: 5,
-    forceRefresh: false
+    forceRefresh: false,
+    locale: input.language,
+    preferLocalizedName: Boolean(input.query) || Boolean(input.language)
   });
   const warnings = [...resolved.warnings];
-  const newsOverview = input.includeNews || input.includePlayerCount ? await buildNewsOverviewData(runtime2, {
+  const newsOverview = input.includeNews || input.includePlayerCount ? await buildAppNewsData(runtime2, {
     toolName: input.toolName,
     appid: resolved.appid,
     count: input.newsCount,
@@ -11754,31 +11998,37 @@ async function buildAppSnapshotData(runtime2, input) {
     includeSchemaDetails: input.includeSchemaDetails,
     topCount: input.topGlobalAchievementsCount
   }) : null;
+  const globalTarget = asRecord(getNestedValue(globalAchievementOverview, "target", "app"));
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    app: {
-      appid: resolved.appid,
-      name: resolved.app?.name,
-      type: resolved.app?.type,
-      resolvedFrom: resolved.resolvedFrom,
-      query: resolved.query
-    },
-    live: input.includePlayerCount ? {
-      currentPlayers: getNestedValue(newsOverview, "game", "currentPlayers")
-    } : void 0,
-    news: input.includeNews ? getNestedValue(newsOverview, "news") : void 0,
-    globalAchievements: input.includeGlobalAchievements ? {
-      summary: getNestedValue(globalAchievementOverview, "achievementSummary"),
-      rarestAchievements: getNestedValue(
-        globalAchievementOverview,
-        "rarestAchievements"
-      ),
-      mostCommonAchievements: getNestedValue(
-        globalAchievementOverview,
-        "mostCommonAchievements"
-      )
-    } : void 0,
+    target: {
+      app: globalTarget ?? resolved.target
+    },
+    summary: {
+      hasNews: input.includeNews,
+      hasPlayerCount: input.includePlayerCount,
+      hasGlobalAchievements: input.includeGlobalAchievements
+    },
+    sections: {
+      live: input.includePlayerCount ? {
+        currentPlayers: getNestedValue(newsOverview, "summary", "currentPlayers")
+      } : void 0,
+      news: input.includeNews ? {
+        summary: getNestedValue(newsOverview, "summary"),
+        items: getNestedValue(newsOverview, "items")
+      } : void 0,
+      globalAchievements: input.includeGlobalAchievements ? {
+        summary: getNestedValue(globalAchievementOverview, "summary"),
+        items: getNestedValue(globalAchievementOverview, "items"),
+        rarest: getNestedValue(globalAchievementOverview, "sections", "rarest"),
+        mostCommon: getNestedValue(
+          globalAchievementOverview,
+          "sections",
+          "mostCommon"
+        )
+      } : void 0
+    },
     warnings: [
       ...warnings,
       ...Array.isArray(getNestedValue(newsOverview, "warnings")) ? getNestedValue(newsOverview, "warnings") : [],
@@ -11787,23 +12037,48 @@ async function buildAppSnapshotData(runtime2, input) {
   };
 }
 
+// src/tools/register-steam-tool.ts
+function isErrorPayload(payload) {
+  return payload.ok === false;
+}
+function withSteamToolAspect(toolName, runtime2, handler) {
+  return async (input) => {
+    try {
+      const payload = await handler(input);
+      return runtime2.createJsonToolResult(payload, isErrorPayload(payload));
+    } catch (error) {
+      return runtime2.createErrorToolResult(toolName, error);
+    }
+  };
+}
+function registerSteamTool(server, runtime2, toolName, definition, handler) {
+  server.registerTool(
+    toolName,
+    definition,
+    // 工具模块只通过这一个入口注册，后续新增工具会默认继承同样的包装行为。
+    async (input) => withSteamToolAspect(toolName, runtime2, handler)(input)
+  );
+}
+
 // src/tools/apps.ts
 function registerAppTools(server, runtime2) {
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_search_apps",
     {
-      title: "Steam \u5E94\u7528\u641C\u7D22",
-      description: "\u6309\u540D\u79F0\u641C\u7D22 Steam \u5E94\u7528\u76EE\u5F55\u5E76\u8FD4\u56DE\u5019\u9009 AppID\u3002",
+      title: "\u641C\u7D22\u6E38\u620F",
+      description: "\u6309\u540D\u79F0\u641C\u7D22 Steam \u5E94\u7528\u76EE\u5F55\uFF0C\u9002\u5408\u62FF\u5019\u9009\u5217\u8868\u3002",
       inputSchema: {
-        query: z2.string().describe("\u8981\u641C\u7D22\u7684\u5E94\u7528\u540D\u79F0\u6216\u540D\u79F0\u7247\u6BB5\u3002"),
-        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\uFF1B\u82E5\u672A\u914D\u7F6E STEAM_WEB_API_KEY\uFF0C\u5219\u6B64\u9879\u5FC5\u586B\u3002"),
+        query: z2.string().describe("\u8981\u641C\u7D22\u7684\u6E38\u620F\u540D\u6216\u5173\u952E\u8BCD\uFF0C\u652F\u6301\u4E2D\u6587\u3002"),
+        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         limit: z2.number().int().min(1).max(50).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u7ED3\u679C\uFF0C\u9ED8\u8BA4 10\u3002"),
-        exactOnly: z2.boolean().optional().describe("\u662F\u5426\u53EA\u8FD4\u56DE\u540D\u79F0\u5B8C\u5168\u5339\u914D\u7684\u7ED3\u679C\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeDlc: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B DLC \u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
+        exactOnly: z2.boolean().optional().describe("\u662F\u5426\u53EA\u8FD4\u56DE\u5B8C\u5168\u5339\u914D\u7684\u7ED3\u679C\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeDlc: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B DLC\uFF0C\u9ED8\u8BA4 false\u3002"),
         includeSoftware: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u8F6F\u4EF6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeVideos: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u89C6\u9891\u548C\u5267\u96C6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeVideos: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u89C6\u9891\u548C\u5267\u96C6\uFF0C\u9ED8\u8BA4 false\u3002"),
         includeHardware: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u786C\u4EF6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
-        forceRefresh: z2.boolean().optional().describe("\u662F\u5426\u8DF3\u8FC7\u5185\u5B58\u4E2D\u7684\u5E94\u7528\u76EE\u5F55\u7F13\u5B58\uFF0C\u9ED8\u8BA4 false\u3002")
+        forceRefresh: z2.boolean().optional().describe("\u662F\u5426\u8DF3\u8FC7\u5E94\u7528\u76EE\u5F55\u7F13\u5B58\uFF0C\u9ED8\u8BA4 false\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -11820,40 +12095,35 @@ function registerAppTools(server, runtime2) {
       includeVideos = false,
       includeHardware = false,
       forceRefresh = false
-    }) => {
-      try {
-        const payload = await buildAppSearchData(runtime2, {
-          toolName: "steam_search_apps",
-          query,
-          key,
-          limit,
-          exactOnly,
-          includeDlc,
-          includeSoftware,
-          includeVideos,
-          includeHardware,
-          forceRefresh
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_search_apps", error);
-      }
-    }
+    }) => buildAppSearchData(runtime2, {
+      toolName: "steam_search_apps",
+      query,
+      key,
+      limit,
+      exactOnly,
+      includeDlc,
+      includeSoftware,
+      includeVideos,
+      includeHardware,
+      forceRefresh
+    })
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_resolve_app",
     {
-      title: "Steam \u5E94\u7528\u89E3\u6790",
-      description: "\u628A\u5E94\u7528\u540D\u79F0\u6216 AppID \u89E3\u6790\u6210\u6700\u53EF\u80FD\u7684\u76EE\u6807 AppID\uFF0C\u5E76\u8FD4\u56DE\u5019\u9009\u7ED3\u679C\u3002",
+      title: "\u89E3\u6790\u6E38\u620F\u76EE\u6807",
+      description: "\u628A\u6E38\u620F\u540D\u6216 AppID \u89E3\u6790\u6210\u6700\u53EF\u80FD\u7684\u76EE\u6807\u6E38\u620F\uFF0C\u5E76\u8FD4\u56DE\u5019\u9009\u5217\u8868\u3002",
       inputSchema: {
-        query: z2.union([z2.string(), z2.number()]).describe("\u8981\u89E3\u6790\u7684 AppID \u6216\u5E94\u7528\u540D\u79F0\u3002"),
-        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\uFF1B\u5982\u679C\u6309\u540D\u79F0\u89E3\u6790\u4E14\u672A\u914D\u7F6E STEAM_WEB_API_KEY\uFF0C\u5219\u6B64\u9879\u5FC5\u586B\u3002"),
+        query: z2.union([z2.string(), z2.number()]).describe("\u6E38\u620F\u540D\u6216 AppID\uFF0C\u652F\u6301\u76F4\u63A5\u8F93\u5165\u4E2D\u6587\u540D\u3002"),
+        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
         limit: z2.number().int().min(1).max(20).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u5019\u9009\u7ED3\u679C\uFF0C\u9ED8\u8BA4 5\u3002"),
-        includeDlc: z2.boolean().optional().describe("\u6309\u540D\u79F0\u89E3\u6790\u65F6\u662F\u5426\u5305\u542B DLC \u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeSoftware: z2.boolean().optional().describe("\u6309\u540D\u79F0\u89E3\u6790\u65F6\u662F\u5426\u5305\u542B\u8F6F\u4EF6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeVideos: z2.boolean().optional().describe("\u6309\u540D\u79F0\u89E3\u6790\u65F6\u662F\u5426\u5305\u542B\u89C6\u9891\u548C\u5267\u96C6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeHardware: z2.boolean().optional().describe("\u6309\u540D\u79F0\u89E3\u6790\u65F6\u662F\u5426\u5305\u542B\u786C\u4EF6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
-        forceRefresh: z2.boolean().optional().describe("\u662F\u5426\u8DF3\u8FC7\u5185\u5B58\u4E2D\u7684\u5E94\u7528\u76EE\u5F55\u7F13\u5B58\uFF0C\u9ED8\u8BA4 false\u3002")
+        includeDlc: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B DLC\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeSoftware: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u8F6F\u4EF6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeVideos: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u89C6\u9891\u548C\u5267\u96C6\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeHardware: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u786C\u4EF6\u6761\u76EE\uFF0C\u9ED8\u8BA4 false\u3002"),
+        forceRefresh: z2.boolean().optional().describe("\u662F\u5426\u8DF3\u8FC7\u5E94\u7528\u76EE\u5F55\u7F13\u5B58\uFF0C\u9ED8\u8BA4 false\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -11869,36 +12139,31 @@ function registerAppTools(server, runtime2) {
       includeVideos = false,
       includeHardware = false,
       forceRefresh = false
-    }) => {
-      try {
-        const payload = await buildAppResolveData(runtime2, {
-          toolName: "steam_resolve_app",
-          query,
-          key,
-          limit,
-          includeDlc,
-          includeSoftware,
-          includeVideos,
-          includeHardware,
-          forceRefresh
-        });
-        return runtime2.createJsonToolResult(payload, payload.ok === false);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_resolve_app", error);
-      }
-    }
+    }) => buildAppResolveData(runtime2, {
+      toolName: "steam_resolve_app",
+      query,
+      key,
+      limit,
+      includeDlc,
+      includeSoftware,
+      includeVideos,
+      includeHardware,
+      forceRefresh
+    })
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_get_global_achievement_overview",
     {
-      title: "Steam \u5168\u5C40\u6210\u5C31\u6982\u89C8",
-      description: "\u6C47\u603B\u67D0\u4E2A\u5E94\u7528\u7684\u5168\u5C40\u6210\u5C31\u5B8C\u6210\u7387\uFF0C\u5E76\u53EF\u9009\u9644\u5E26 schema \u5143\u6570\u636E\u3002",
+      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",
       inputSchema: {
-        appid: z2.union([z2.string(), z2.number()]).optional().describe("\u8981\u67E5\u770B\u7684 Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
-        query: z2.union([z2.string(), z2.number()]).optional().describe("\u5148\u89E3\u6790\u518D\u67E5\u8BE2\u7684\u5E94\u7528\u540D\u79F0\u6216 AppID\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
-        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\uFF1B\u6309\u540D\u79F0\u89E3\u6790\u548C\u83B7\u53D6 schema \u5143\u6570\u636E\u65F6\u9700\u8981\u3002"),
-        language: z2.string().optional().describe("\u53EF\u9009\u7684 schema \u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 'schinese' \u6216 'english'\u3002"),
-        includeSchemaDetails: z2.boolean().optional().describe("\u662F\u5426\u7528 schema \u7684\u663E\u793A\u540D\u548C\u63CF\u8FF0\u8865\u5145\u6210\u5C31\u4FE1\u606F\uFF0C\u9ED8\u8BA4 true\u3002"),
+        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\u3002"),
+        language: z2.string().optional().describe("\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 schinese \u6216 english\u3002"),
+        includeSchemaDetails: z2.boolean().optional().describe("\u662F\u5426\u4F7F\u7528 schema \u8865\u5145\u663E\u793A\u540D\u548C\u63CF\u8FF0\uFF0C\u9ED8\u8BA4 true\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: {
@@ -11913,39 +12178,34 @@ function registerAppTools(server, runtime2) {
       language,
       includeSchemaDetails = true,
       topCount = 10
-    }) => {
-      try {
-        const payload = await buildGlobalAchievementOverviewData(runtime2, {
-          toolName: "steam_get_global_achievement_overview",
-          appid,
-          query,
-          key,
-          language,
-          includeSchemaDetails,
-          topCount
-        });
-        return runtime2.createJsonToolResult(payload, payload.ok === false);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_get_global_achievement_overview", error);
-      }
-    }
+    }) => buildGlobalAchievementOverviewData(runtime2, {
+      toolName: "steam_get_global_achievement_overview",
+      appid,
+      query,
+      key,
+      language,
+      includeSchemaDetails,
+      topCount
+    })
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_get_app_snapshot",
     {
-      title: "Steam \u5E94\u7528\u5FEB\u7167",
-      description: "\u805A\u5408\u5E94\u7528\u57FA\u672C\u4FE1\u606F\u3001\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\u3001\u6700\u8FD1\u65B0\u95FB\u548C\u5168\u5C40\u6210\u5C31\u8D8B\u52BF\u3002",
+      title: "\u6E38\u620F\u5FEB\u7167",
+      description: "\u516C\u5171\u5355\u6E38\u620F\u4E3B\u5165\u53E3\uFF0C\u805A\u5408\u65B0\u95FB\u3001\u5728\u7EBF\u4EBA\u6570\u548C\u5168\u5C40\u6210\u5C31\u4FE1\u606F\u3002",
       inputSchema: {
-        appid: z2.union([z2.string(), z2.number()]).optional().describe("\u8981\u67E5\u770B\u7684 Steam AppID\u3002\u4E0E query \u4E8C\u9009\u4E00\u3002"),
-        query: z2.union([z2.string(), z2.number()]).optional().describe("\u5148\u89E3\u6790\u518D\u67E5\u8BE2\u7684\u5E94\u7528\u540D\u79F0\u6216 AppID\u3002\u4E0E appid \u4E8C\u9009\u4E00\u3002"),
-        key: z2.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\uFF1B\u6309\u540D\u79F0\u89E3\u6790\u548C\u83B7\u53D6 schema \u5143\u6570\u636E\u65F6\u9700\u8981\u3002"),
-        language: z2.string().optional().describe("\u53EF\u9009\u7684 schema \u8BED\u8A00\u4EE3\u7801\u3002"),
-        includeNews: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u7684 Steam \u65B0\u95FB\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includePlayerCount: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5F53\u524D\u5168\u7403\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeGlobalAchievements: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5168\u5C40\u6210\u5C31\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeSchemaDetails: z2.boolean().optional().describe("\u662F\u5426\u7528 schema \u5143\u6570\u636E\u8865\u5145\u5168\u5C40\u6210\u5C31\u4FE1\u606F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        newsCount: z2.number().int().min(1).max(10).optional().describe("\u8FD4\u56DE\u591A\u5C11\u6761\u65B0\u95FB\uFF0C\u9ED8\u8BA4 3\u3002"),
-        newsMaxLength: z2.number().int().min(0).max(1e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u5185\u5BB9\u7684\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 180\u3002"),
+        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\u3002"),
+        language: z2.string().optional().describe("\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 schinese \u6216 english\u3002"),
+        includeNews: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u65B0\u95FB\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includePlayerCount: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeGlobalAchievements: z2.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5168\u5C40\u6210\u5C31\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeSchemaDetails: z2.boolean().optional().describe("\u662F\u5426\u5728\u5168\u5C40\u6210\u5C31\u91CC\u8865\u5145 schema \u7EC6\u8282\uFF0C\u9ED8\u8BA4 true\u3002"),
+        newsCount: z2.number().int().min(1).max(10).optional().describe("\u65B0\u95FB\u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 3\u3002"),
+        newsMaxLength: z2.number().int().min(0).max(5e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 180\u3002"),
         topGlobalAchievementsCount: 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: {
@@ -11953,6 +12213,7 @@ function registerAppTools(server, runtime2) {
         openWorldHint: true
       }
     },
+    // 这里刻意把 snapshot 保留成公共单游戏主入口；更窄的专项工具再单独暴露。
     async ({
       appid,
       query,
@@ -11965,198 +12226,25 @@ function registerAppTools(server, runtime2) {
       newsCount = 3,
       newsMaxLength = 180,
       topGlobalAchievementsCount = 10
-    }) => {
-      try {
-        const payload = await buildAppSnapshotData(runtime2, {
-          toolName: "steam_get_app_snapshot",
-          appid,
-          query,
-          key,
-          language,
-          includeNews,
-          includePlayerCount,
-          includeGlobalAchievements,
-          includeSchemaDetails,
-          newsCount,
-          newsMaxLength,
-          topGlobalAchievementsCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_get_app_snapshot", error);
-      }
-    }
+    }) => buildAppSnapshotData(runtime2, {
+      toolName: "steam_get_app_snapshot",
+      appid,
+      query,
+      key,
+      language,
+      includeNews,
+      includePlayerCount,
+      includeGlobalAchievements,
+      includeSchemaDetails,
+      newsCount,
+      newsMaxLength,
+      topGlobalAchievementsCount
+    })
   );
 }
 
-// src/tools/generated.ts
-function registerGeneratedTools(server, runtime2) {
-  for (const method of runtime2.spec.methods) {
-    const inputSchema = buildInputSchema(method, {
-      defaultSteamId: runtime2.config.defaultSteamId
-    });
-    const annotations = {
-      readOnlyHint: method.httpMethod === "GET",
-      openWorldHint: true
-    };
-    server.registerTool(
-      method.toolName,
-      {
-        title: createGeneratedToolTitle(method),
-        description: createToolDescription(method),
-        ...inputSchema ? { inputSchema } : {},
-        annotations
-      },
-      async (args) => runtime2.executeSteamMethod(method, args ?? {})
-    );
-  }
-}
-
-// src/tools/helpers.ts
+// src/tools/me.ts
 import * as z3 from "zod/v4";
-function registerHelperTools(server, runtime2) {
-  server.registerTool(
-    "steam_list_interfaces",
-    {
-      title: "Steam \u63A5\u53E3\u5217\u8868",
-      description: "\u5217\u51FA\u5F53\u524D\u5DF2\u540C\u6B65\u7684 Steam Web API \u63A5\u53E3\u3002",
-      inputSchema: {
-        search: z3.string().optional().describe("\u53EF\u9009\u5173\u952E\u5B57\uFF0C\u5927\u5C0F\u5199\u4E0D\u654F\u611F\uFF0C\u5339\u914D\u63A5\u53E3\u540D\u6216\u63A5\u53E3\u63CF\u8FF0\u3002"),
-        serviceOnly: z3.boolean().optional().describe("\u662F\u5426\u53EA\u8FD4\u56DE Steam Service Interface\u3002")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: false
-      }
-    },
-    async ({ search, serviceOnly }) => {
-      const query = search?.toLowerCase();
-      const interfaces = runtime2.spec.interfaces.filter((entry) => {
-        if (serviceOnly && !entry.serviceInterface) {
-          return false;
-        }
-        if (!query) {
-          return true;
-        }
-        return entry.name.toLowerCase().includes(query) || entry.description.toLowerCase().includes(query);
-      });
-      const content = {
-        generatedAt: runtime2.spec.generatedAt,
-        interfaceCount: interfaces.length,
-        interfaces: interfaces.map((entry) => ({
-          name: entry.name,
-          description: entry.description,
-          serviceInterface: entry.serviceInterface,
-          sourceUrl: entry.sourceUrl,
-          methodCount: runtime2.spec.methods.filter(
-            (method) => method.interfaceName === entry.name
-          ).length
-        }))
-      };
-      return runtime2.createJsonToolResult(content);
-    }
-  );
-  server.registerTool(
-    "steam_list_methods",
-    {
-      title: "Steam \u65B9\u6CD5\u641C\u7D22",
-      description: "\u641C\u7D22\u5F53\u524D\u5DF2\u540C\u6B65\u7684 Steam Web API \u65B9\u6CD5\u76EE\u5F55\u3002",
-      inputSchema: {
-        interfaceName: z3.string().optional().describe("\u53EF\u9009\u63A5\u53E3\u540D\u8FC7\u6EE4\uFF0C\u4F8B\u5982 ISteamUserStats\u3002"),
-        search: z3.string().optional().describe("\u53EF\u9009\u5173\u952E\u5B57\uFF0C\u5927\u5C0F\u5199\u4E0D\u654F\u611F\uFF0C\u5339\u914D\u65B9\u6CD5\u540D\u6216\u65B9\u6CD5\u63CF\u8FF0\u3002"),
-        auth: z3.enum(["any", "anonymous", "userKey", "publisherKey"]).optional().describe("\u6309\u9274\u6743\u8981\u6C42\u8FC7\u6EE4\u3002"),
-        limit: z3.number().int().min(1).max(500).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u65B9\u6CD5\uFF0C\u9ED8\u8BA4 50\u3002")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: false
-      }
-    },
-    async ({ interfaceName, search, auth = "any", limit = 50 }) => {
-      const query = search?.toLowerCase();
-      const methods = runtime2.spec.methods.filter((method) => {
-        if (interfaceName && method.interfaceName !== interfaceName) {
-          return false;
-        }
-        if (auth === "anonymous" && !method.supportsAnonymous) {
-          return false;
-        }
-        if (auth === "userKey" && !method.requiresUserKey) {
-          return false;
-        }
-        if (auth === "publisherKey" && !method.requiresPublisherKey) {
-          return false;
-        }
-        if (!query) {
-          return true;
-        }
-        return method.methodName.toLowerCase().includes(query) || method.interfaceName.toLowerCase().includes(query) || method.description.toLowerCase().includes(query);
-      });
-      const content = {
-        generatedAt: runtime2.spec.generatedAt,
-        totalMatches: methods.length,
-        returned: Math.min(methods.length, limit),
-        methods: methods.slice(0, limit).map((method) => ({
-          interfaceName: method.interfaceName,
-          methodName: method.methodName,
-          toolName: method.toolName,
-          httpMethod: method.httpMethod,
-          serviceInterface: method.serviceInterface,
-          requiresUserKey: method.requiresUserKey,
-          requiresPublisherKey: method.requiresPublisherKey,
-          supportsAnonymous: method.supportsAnonymous,
-          sourceUrl: method.sourceUrl
-        }))
-      };
-      return runtime2.createJsonToolResult(content);
-    }
-  );
-  server.registerTool(
-    "steam_get_method_details",
-    {
-      title: "Steam \u65B9\u6CD5\u8BE6\u60C5",
-      description: "\u67E5\u770B\u67D0\u4E2A\u5DF2\u540C\u6B65 Steam Web API \u65B9\u6CD5\u7684\u5B8C\u6574\u5143\u4FE1\u606F\u3002",
-      inputSchema: {
-        toolName: z3.string().optional().describe("\u751F\u6210\u540E\u7684 MCP tool \u540D\uFF0C\u4F8B\u5982 steam_i_player_service_get_owned_games\u3002"),
-        interfaceName: z3.string().optional().describe("\u4E0D\u4F7F\u7528 toolName \u65F6\u53EF\u4F20\u63A5\u53E3\u540D\u3002"),
-        methodName: z3.string().optional().describe("\u4E0D\u4F7F\u7528 toolName \u65F6\u53EF\u4F20\u65B9\u6CD5\u540D\u3002")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: false
-      }
-    },
-    async ({ toolName, interfaceName, methodName }) => {
-      const method = runtime2.resolveMethod({ toolName, interfaceName, methodName });
-      return runtime2.createJsonToolResult(method);
-    }
-  );
-  server.registerTool(
-    "steam_call_raw",
-    {
-      title: "Steam \u539F\u59CB\u8C03\u7528",
-      description: "\u6309\u63A5\u53E3\u540D\u548C\u65B9\u6CD5\u540D\u76F4\u63A5\u8C03\u7528\u4EFB\u610F\u5DF2\u540C\u6B65\u7684 Steam Web API \u65B9\u6CD5\u3002\u9002\u5408\u5728\u751F\u6210\u5DE5\u5177\u7EA6\u675F\u8FC7\u4E25\u65F6\u515C\u5E95\u4F7F\u7528\u3002",
-      inputSchema: {
-        interfaceName: z3.string().describe("Steam Web API \u63A5\u53E3\u540D\uFF0C\u4F8B\u5982 ISteamUserStats\u3002"),
-        methodName: z3.string().describe("Steam Web API \u65B9\u6CD5\u540D\uFF0C\u4F8B\u5982 GetNumberOfCurrentPlayers\u3002"),
-        params: z3.record(z3.string(), z3.any()).optional().describe("\u539F\u59CB\u53C2\u6570\u5BF9\u8C61\uFF0C\u952E\u540D\u53EF\u4EE5\u4F7F\u7528 Steam \u539F\u59CB\u53C2\u6570\u540D\u6216\u751F\u6210\u540E\u7684\u8F93\u5165\u53C2\u6570\u540D\u3002"),
-        key: z3.string().optional().describe("\u53EF\u9009 API key \u8986\u76D6\u503C\uFF1B\u4E0D\u4F20\u65F6\u56DE\u9000\u5230 STEAM_WEB_API_KEY\u3002")
-      },
-      annotations: {
-        readOnlyHint: false,
-        openWorldHint: true
-      }
-    },
-    async ({ interfaceName, methodName, params = {}, key }) => {
-      const method = runtime2.resolveMethod({ interfaceName, methodName });
-      const mappedArgs = runtime2.mapRawParams(method, params);
-      return runtime2.executeSteamMethod(method, { ...mappedArgs, key });
-    }
-  );
-}
-
-// src/tools/me.ts
-import * as z4 from "zod/v4";
 
 // src/services/account.ts
 async function buildRecentlyPlayedData(runtime2, input) {
@@ -12176,16 +12264,21 @@ async function buildRecentlyPlayedData(runtime2, input) {
       apiKey
     )
   ]);
+  const recentGames = normalizeRecentlyPlayedGames(recentGamesCall.data);
+  const items = getRecordItems(recentGames?.games);
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data)
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
+      requestedCount: input.count,
+      totalCount: toNumber(recentGames?.totalCount) ?? items.length,
+      returnedCount: items.length
+    },
+    items,
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data)
     },
-    recentlyPlayed: normalizeRecentlyPlayedGames(recentGamesCall.data),
     warnings: runtime2.collectWarnings([playerSummaryCall, recentGamesCall])
   };
 }
@@ -12212,17 +12305,20 @@ async function buildBadgesOverviewData(runtime2, input) {
       apiKey
     )
   ]);
+  const badges = normalizeBadgeSummary(badgesCall.data);
   const level = toNumber(getNestedValue(steamLevelCall.data, "response", "player_level")) ?? toNumber(getNestedValue(steamLevelCall.data, "player_level"));
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data),
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
       level,
-      badges: normalizeBadgeSummary(badgesCall.data)
+      badgeCount: toNumber(badges?.badgeCount) ?? 0,
+      playerXp: toNumber(badges?.playerXp) ?? null
+    },
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data),
+      badges
     },
     warnings: runtime2.collectWarnings([playerSummaryCall, steamLevelCall, badgesCall])
   };
@@ -12244,15 +12340,21 @@ async function buildBansData(runtime2, input) {
       apiKey
     )
   ]);
+  const bans = normalizePlayerBan(bansCall.data);
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data),
-      bans: normalizePlayerBan(bansCall.data)
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
+      communityBanned: toBoolean(bans?.communityBanned) ?? false,
+      vacBanned: toBoolean(bans?.vacBanned) ?? false,
+      numberOfVacBans: toNumber(bans?.numberOfVacBans) ?? 0,
+      numberOfGameBans: toNumber(bans?.numberOfGameBans) ?? 0,
+      daysSinceLastBan: toNumber(bans?.daysSinceLastBan) ?? null
+    },
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data),
+      bans
     },
     warnings: runtime2.collectWarnings([playerSummaryCall, bansCall])
   };
@@ -12290,24 +12392,25 @@ async function buildFriendsData(runtime2, input) {
   const friendIds = limitedFriends.map((friend) => friend.steamid).filter((steamid) => Boolean(steamid));
   const summaryMap = input.includeSummaries && friendIds.length > 0 ? await runtime2.fetchPlayerSummaryMap(friendIds, apiKey) : /* @__PURE__ */ new Map();
   const banMap = input.includeBans && friendIds.length > 0 ? await runtime2.fetchPlayerBanMap(friendIds, apiKey) : /* @__PURE__ */ new Map();
+  const items = limitedFriends.map((friend) => ({
+    ...friend,
+    summary: friend.steamid ? summaryMap.get(friend.steamid) ?? null : null,
+    bans: friend.steamid ? banMap.get(friend.steamid) ?? null : null
+  }));
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data)
-    },
-    friends: {
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
       relationship: input.relationship,
       totalFriends: allFriends.length,
-      returnedFriends: limitedFriends.length,
-      items: limitedFriends.map((friend) => ({
-        ...friend,
-        summary: friend.steamid ? summaryMap.get(friend.steamid) ?? null : null,
-        bans: friend.steamid ? banMap.get(friend.steamid) ?? null : null
-      }))
+      returnedFriends: items.length,
+      includeSummaries: input.includeSummaries,
+      includeBans: input.includeBans
+    },
+    items,
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data)
     },
     warnings: runtime2.collectWarnings([playerSummaryCall, friendListCall])
   };
@@ -12315,7 +12418,16 @@ async function buildFriendsData(runtime2, input) {
 async function buildGameSnapshotData(runtime2, input) {
   const apiKey = runtime2.requireSteamApiKey(input.toolName, input.key);
   const identity = await runtime2.resolvePlayerIdentity({}, apiKey);
-  const appIdValue = normalizeScalarInput(input.appid);
+  const resolved = await runtime2.resolveAppSelection({
+    toolName: input.toolName,
+    appid: input.appid,
+    query: input.query,
+    key: apiKey,
+    limit: 5,
+    forceRefresh: false,
+    locale: input.language,
+    preferLocalizedName: Boolean(input.query) || Boolean(input.language)
+  });
   const [playerSummaryCall, ownedGamesCall] = await Promise.all([
     runtime2.safeInvokeKnownMethod(
       "ISteamUser",
@@ -12330,128 +12442,78 @@ async function buildGameSnapshotData(runtime2, input) {
         steamid: identity.steamid,
         include_appinfo: true,
         include_played_free_games: true,
-        appids_filter: [appIdValue]
+        appids_filter: [resolved.appid]
       },
       apiKey
     )
   ]);
   const ownedGames = normalizeOwnedGames(ownedGamesCall.data);
   const ownedGame = ownedGames.games[0] ?? null;
-  const achievementOverview = input.includeAchievements || input.includeStats ? await buildAchievementOverviewData(runtime2, {
+  const achievementOverview = input.includeAchievements || input.includeStats ? await buildPlayerGameAchievementsData(runtime2, {
     toolName: input.toolName,
     steamid: identity.steamid,
-    appid: appIdValue ?? "",
+    appid: resolved.appid,
     key: apiKey,
     language: input.language,
     includeStats: input.includeStats,
     recentUnlockedCount: 10
   }) : null;
-  const newsOverview = input.includeNews ? await buildNewsOverviewData(runtime2, {
+  const newsOverview = input.includeNews || input.includePlayerCount ? await buildAppNewsData(runtime2, {
     toolName: input.toolName,
-    appid: appIdValue ?? "",
-    count: input.newsCount,
-    maxlength: input.newsMaxLength,
+    appid: resolved.appid,
+    count: input.includeNews ? input.newsCount : 1,
+    maxlength: input.includeNews ? input.newsMaxLength : 0,
     includePlayerCount: input.includePlayerCount
-  }) : input.includePlayerCount ? await buildNewsOverviewData(runtime2, {
-    toolName: input.toolName,
-    appid: appIdValue ?? "",
-    count: 1,
-    maxlength: 0,
-    includePlayerCount: true
   }) : null;
+  const appTarget = getRecord(getNestedValue(achievementOverview, "target", "app")) ?? getRecord(getNestedValue(newsOverview, "target", "app")) ?? resolved.target;
+  const warnings = [
+    ...resolved.warnings,
+    ...runtime2.collectWarnings([playerSummaryCall, ownedGamesCall]),
+    ...getWarnings(achievementOverview),
+    ...getWarnings(newsOverview)
+  ];
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data)
+    target: {
+      player: buildDefaultPlayerTarget(identity).player,
+      app: appTarget
     },
-    game: {
-      appid: appIdValue,
+    summary: {
       owned: Boolean(ownedGame),
+      playtimeForeverMinutes: toNumber(ownedGame?.playtimeForeverMinutes) ?? 0,
+      playtimeForeverHours: toNumber(ownedGame?.playtimeForeverHours) ?? 0,
+      hasAchievements: input.includeAchievements,
+      hasStats: input.includeStats,
+      hasNews: input.includeNews,
+      hasPlayerCount: input.includePlayerCount
+    },
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data),
       ownership: ownedGame,
-      currentPlayers: newsOverview && input.includePlayerCount ? getNestedValue(newsOverview, "game", "currentPlayers") : void 0,
-      news: newsOverview && input.includeNews ? getNestedValue(newsOverview, "news") : void 0,
-      achievementOverview: achievementOverview && input.includeAchievements ? {
-        achievementSummary: getNestedValue(
+      live: input.includePlayerCount ? {
+        currentPlayers: getNestedValue(newsOverview, "summary", "currentPlayers")
+      } : void 0,
+      news: input.includeNews ? {
+        summary: getNestedValue(newsOverview, "summary"),
+        items: getNestedValue(newsOverview, "items")
+      } : void 0,
+      achievements: input.includeAchievements ? {
+        summary: getNestedValue(achievementOverview, "summary"),
+        items: getNestedValue(achievementOverview, "items"),
+        recentlyUnlocked: getNestedValue(
           achievementOverview,
-          "achievementSummary"
-        ),
-        achievements: getNestedValue(achievementOverview, "achievements")
+          "sections",
+          "recentlyUnlocked"
+        )
       } : void 0,
-      stats: achievementOverview && input.includeStats ? getNestedValue(achievementOverview, "stats") : void 0
+      stats: input.includeStats ? getNestedValue(achievementOverview, "sections", "stats") : void 0
     },
-    warnings: [
-      ...runtime2.collectWarnings([playerSummaryCall, ownedGamesCall]),
-      ...Array.isArray(getNestedValue(achievementOverview, "warnings")) ? getNestedValue(achievementOverview, "warnings") : [],
-      ...Array.isArray(getNestedValue(newsOverview, "warnings")) ? getNestedValue(newsOverview, "warnings") : []
-    ]
+    warnings
   };
 }
-async function buildGroupsData(runtime2, input) {
-  const apiKey = runtime2.requireSteamApiKey(input.toolName, input.key);
-  const identity = await runtime2.resolvePlayerIdentity({}, apiKey);
-  const [playerSummaryCall, groupListCall] = await Promise.all([
-    runtime2.safeInvokeKnownMethod(
-      "ISteamUser",
-      "GetPlayerSummaries",
-      { steamids: identity.steamid },
-      apiKey
-    ),
-    runtime2.safeInvokeKnownMethod(
-      "ISteamUser",
-      "GetUserGroupList",
-      { steamid: identity.steamid },
-      apiKey
-    )
-  ]);
-  if (!groupListCall.ok) {
-    return {
-      ok: false,
-      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      player: {
-        steamid: identity.steamid,
-        resolvedFrom: identity.resolvedFrom,
-        vanityUrl: identity.vanityUrl,
-        summary: normalizePlayerSummary(playerSummaryCall.data)
-      },
-      note: "Steam docs currently mark ISteamUser.GetUserGroupList as requiring a publisher key, so normal user keys often fail here.",
-      warnings: runtime2.collectWarnings([playerSummaryCall, groupListCall])
-    };
-  }
-  const groups = [];
-  for (const entry of getNestedArray(groupListCall.data, "response", "groups")) {
-    const group = asRecord(entry);
-    if (!group) {
-      continue;
-    }
-    groups.push({
-      gid: getStringValue(group.gid)
-    });
-  }
-  return {
-    ok: true,
-    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data)
-    },
-    groups: {
-      totalGroups: groups.length,
-      items: groups
-    },
-    warnings: runtime2.collectWarnings([playerSummaryCall, groupListCall])
-  };
-}
-async function buildWishlistLikeFeedData(runtime2, input) {
+async function buildGameFeedData(runtime2, input) {
   const explicitAppIds = parseAppIdCollection(input.appids);
-  const sourceMeta = {
-    source: input.source
-  };
   const needsUserContext = input.source === "recent" || input.source === "topOwned" || input.source === "mixed" || input.includeOwnedContext;
   const apiKey = needsUserContext ? runtime2.requireSteamApiKey(input.toolName, input.key) : input.key ?? runtime2.config.apiKey;
   const identity = await runtime2.resolvePlayerIdentity({}, apiKey);
@@ -12490,23 +12552,20 @@ async function buildWishlistLikeFeedData(runtime2, input) {
       apiKey,
       input.limitApps
     );
-    selectedAppIds = [.../* @__PURE__ */ new Set([
-      ...recentAppIds,
-      ...topOwnedAppIds,
-      ...explicitAppIds
-    ])];
+    selectedAppIds = [.../* @__PURE__ */ new Set([...recentAppIds, ...topOwnedAppIds, ...explicitAppIds])];
   }
   if (selectedAppIds.length === 0) {
     return {
       ok: false,
       requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      player: {
-        steamid: identity.steamid,
-        resolvedFrom: identity.resolvedFrom,
-        vanityUrl: identity.vanityUrl
+      target: buildDefaultPlayerTarget(identity),
+      summary: {
+        source: input.source,
+        appCount: 0,
+        feedItemCount: 0
       },
-      note: "No apps were selected for the feed. Provide appids or switch to a source that can derive apps from your account.",
-      source: sourceMeta,
+      items: [],
+      note: input.source === "explicit" ? "No AppIDs were provided for source='explicit'." : "No apps were selected for the feed.",
       warnings: []
     };
   }
@@ -12516,48 +12575,52 @@ async function buildWishlistLikeFeedData(runtime2, input) {
     identity.steamid,
     runtime2.requireSteamApiKey(input.toolName, input.key)
   ) : /* @__PURE__ */ new Map();
-  const appResults = await Promise.all(
+  const appSections = await Promise.all(
     selectedAppIds.map(async (appid) => {
-      const newsOverview = await buildNewsOverviewData(runtime2, {
+      const newsOverview = await buildAppNewsData(runtime2, {
         toolName: input.toolName,
         appid,
         count: input.newsPerApp,
         maxlength: input.newsMaxLength,
         includePlayerCount: input.includePlayerCount
       });
+      const appTarget = getRecord(getNestedValue(newsOverview, "target", "app"));
+      const newsItems = getRecordItems(getNestedValue(newsOverview, "items"));
       return {
-        appid,
-        currentPlayers: getNestedValue(newsOverview, "game", "currentPlayers"),
+        app: appTarget,
+        currentPlayers: getNestedValue(newsOverview, "summary", "currentPlayers"),
         ownedContext: ownedContextMap.get(appid) ?? null,
-        news: getNestedValue(newsOverview, "news", "items"),
-        warnings: getNestedValue(newsOverview, "warnings")
+        items: newsItems,
+        warnings: getWarnings(newsOverview)
       };
     })
   );
-  const flatFeed = appResults.flatMap(
-    (app) => Array.isArray(app.news) ? app.news.map((item) => ({
-      appid: app.appid,
-      currentPlayers: app.currentPlayers,
-      ownedContext: app.ownedContext,
+  const items = appSections.flatMap(
+    (section) => section.items.map((item) => ({
+      app: section.app,
+      currentPlayers: section.currentPlayers,
+      ownedContext: section.ownedContext,
       item
-    })) : []
+    }))
   ).sort(
     (left, right) => (toNumber(asRecord(right.item)?.date) ?? 0) - (toNumber(asRecord(left.item)?.date) ?? 0)
   );
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
+      source: input.source,
+      appCount: appSections.length,
+      feedItemCount: items.length,
+      includeOwnedContext: input.includeOwnedContext,
+      includePlayerCount: input.includePlayerCount
     },
-    source: sourceMeta,
-    apps: appResults,
-    feed: flatFeed,
-    warnings: appResults.flatMap(
-      (app) => Array.isArray(app.warnings) ? app.warnings : []
-    )
+    items,
+    sections: {
+      apps: appSections
+    },
+    warnings: appSections.flatMap((section) => section.warnings)
   };
 }
 async function buildFriendActivityData(runtime2, input) {
@@ -12569,19 +12632,17 @@ async function buildFriendActivityData(runtime2, input) {
     includeBans: input.includeBans,
     limit: input.limit
   });
-  const friendItems = Array.isArray(getNestedValue(friendsData, "friends", "items")) ? getNestedValue(friendsData, "friends", "items") ?? [] : [];
+  const friendItems = getRecordItems(getNestedValue(friendsData, "items"));
   const normalizedActivity = friendItems.map((entry) => normalizeFriendActivityItem(entry)).filter(
     (entry) => entry !== null && (!input.onlyInGame || toBoolean(entry.inGame) === true)
   ).sort(compareFriendActivityItems);
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: getNestedValue(friendsData, "player"),
-    activity: {
-      inspectedFriends: toNumber(
-        getNestedValue(friendsData, "friends", "returnedFriends")
-      ),
-      totalFriends: toNumber(getNestedValue(friendsData, "friends", "totalFriends")),
+    target: getNestedValue(friendsData, "target"),
+    summary: {
+      inspectedFriends: toNumber(getNestedValue(friendsData, "summary", "returnedFriends")),
+      totalFriends: toNumber(getNestedValue(friendsData, "summary", "totalFriends")),
       returnedFriends: normalizedActivity.length,
       currentlyInGameCount: normalizedActivity.filter(
         (entry) => toBoolean(entry.inGame) === true
@@ -12589,9 +12650,13 @@ async function buildFriendActivityData(runtime2, input) {
       onlineCount: normalizedActivity.filter(
         (entry) => toBoolean(entry.online) === true
       ).length,
-      items: normalizedActivity
+      onlyInGame: input.onlyInGame
     },
-    warnings: Array.isArray(getNestedValue(friendsData, "warnings")) ? getNestedValue(friendsData, "warnings") : []
+    items: normalizedActivity,
+    sections: {
+      profile: getNestedValue(friendsData, "sections", "profile")
+    },
+    warnings: getWarnings(friendsData)
   };
 }
 async function buildFriendNetworkData(runtime2, input) {
@@ -12603,10 +12668,10 @@ async function buildFriendNetworkData(runtime2, input) {
     includeBans: input.includeBans,
     limit: input.limit
   });
-  const player = asRecord(getNestedValue(friendsData, "player"));
-  const playerSummary = asRecord(player?.summary);
-  const playerSteamId = getStringValue(player?.steamid) ?? runtime2.config.defaultSteamId ?? "";
-  const friendItems = Array.isArray(getNestedValue(friendsData, "friends", "items")) ? getNestedValue(friendsData, "friends", "items") ?? [] : [];
+  const playerTarget = getRecord(getNestedValue(friendsData, "target", "player"));
+  const playerSummary = getRecord(getNestedValue(friendsData, "sections", "profile"));
+  const playerSteamId = getStringValue(playerTarget?.steamid) ?? runtime2.config.defaultSteamId ?? "";
+  const friendItems = getRecordItems(getNestedValue(friendsData, "items"));
   const normalizedFriends = friendItems.map((entry) => normalizeFriendActivityItem(entry)).filter((entry) => entry !== null).sort(compareFriendActivityItems);
   const recentThreshold = Math.floor(Date.now() / 1e3) - input.activityWindowHours * 60 * 60;
   const inGameFriends = normalizedFriends.filter(
@@ -12635,12 +12700,10 @@ async function buildFriendNetworkData(runtime2, input) {
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: getNestedValue(friendsData, "player"),
-    networkSummary: {
-      totalFriends: toNumber(getNestedValue(friendsData, "friends", "totalFriends")),
-      inspectedFriends: toNumber(
-        getNestedValue(friendsData, "friends", "returnedFriends")
-      ),
+    target: getNestedValue(friendsData, "target"),
+    summary: {
+      totalFriends: toNumber(getNestedValue(friendsData, "summary", "totalFriends")),
+      inspectedFriends: toNumber(getNestedValue(friendsData, "summary", "returnedFriends")),
       onlineCount: onlineFriends.length,
       inGameCount: inGameFriends.length,
       recentlyActiveCount: recentlyActiveFriends.length,
@@ -12648,18 +12711,21 @@ async function buildFriendNetworkData(runtime2, input) {
       activeGameCount: gameGroups.length,
       activityWindowHours: input.activityWindowHours
     },
-    groups: {
-      inGameByTitle: gameGroups,
-      online: onlineFriends,
-      recentlyActive: recentlyActiveFriends,
-      offline: normalizedFriends.filter(
-        (entry) => toBoolean(entry.online) !== true && !recentlyActiveFriends.some(
-          (candidate) => getStringValue(candidate.steamid) === getStringValue(entry.steamid)
+    sections: {
+      profile: playerSummary,
+      groups: {
+        inGameByTitle: gameGroups,
+        online: onlineFriends,
+        recentlyActive: recentlyActiveFriends,
+        offline: normalizedFriends.filter(
+          (entry) => toBoolean(entry.online) !== true && !recentlyActiveFriends.some(
+            (candidate) => getStringValue(candidate.steamid) === getStringValue(entry.steamid)
+          )
         )
-      )
+      },
+      graph
     },
-    graph,
-    warnings: Array.isArray(getNestedValue(friendsData, "warnings")) ? getNestedValue(friendsData, "warnings") : []
+    warnings: getWarnings(friendsData)
   };
 }
 async function buildBacklogCandidatesData(runtime2, input) {
@@ -12745,35 +12811,31 @@ async function buildBacklogCandidatesData(runtime2, input) {
       };
     })
   );
-  const candidates = shortlist.sort(compareBacklogCandidates).slice(0, input.limit);
+  const items = shortlist.sort(compareBacklogCandidates).slice(0, input.limit);
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data)
-    },
-    backlogSummary: {
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
       ownedGameCount: ownedGames.length,
       backlogPoolCount: backlogPool.length,
-      returnedCandidates: candidates.length,
-      neverPlayedCount: candidates.filter(
+      returnedCount: items.length,
+      neverPlayedCount: items.filter(
         (candidate) => toBoolean(candidate.neverPlayed) === true
       ).length,
-      barelyPlayedCount: candidates.filter(
+      barelyPlayedCount: items.filter(
         (candidate) => toBoolean(candidate.neverPlayed) !== true && (toNumber(candidate.playtimeForeverHours) ?? 0) <= input.maxPlaytimeHours
       ).length,
       maxPlaytimeHours: input.maxPlaytimeHours,
       minDaysSinceLastPlayed: input.minDaysSinceLastPlayed
     },
-    candidates,
+    items,
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data)
+    },
     warnings: [
       ...runtime2.collectWarnings([playerSummaryCall, ownedGamesCall]),
-      ...shortlist.flatMap(
-        (candidate) => Array.isArray(candidate.warnings) ? candidate.warnings : []
-      )
+      ...shortlist.flatMap((candidate) => getWarnings(candidate))
     ]
   };
 }
@@ -12819,21 +12881,21 @@ async function buildAchievementHuntData(runtime2, input) {
     return {
       ok: false,
       requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      player: {
-        steamid: identity.steamid,
-        resolvedFrom: identity.resolvedFrom,
-        vanityUrl: identity.vanityUrl,
-        summary: normalizePlayerSummary(playerSummaryCall.data)
+      target: buildDefaultPlayerTarget(identity),
+      summary: {
+        source: input.source,
+        inspectedGameCount: 0,
+        candidateCount: 0
       },
+      items: [],
       note: input.source === "explicit" ? "No AppIDs were provided for source='explicit'." : "No suitable games were selected to inspect for achievements.",
-      source: input.source,
       warnings: runtime2.collectWarnings([playerSummaryCall, ownedGamesCall])
     };
   }
   const inspectedGames = await Promise.all(
     appIdsToInspect.map(async (appid) => {
       try {
-        const overview = await buildAchievementOverviewData(runtime2, {
+        const overview = await buildPlayerGameAchievementsData(runtime2, {
           toolName: input.toolName,
           steamid: identity.steamid,
           appid,
@@ -12842,8 +12904,9 @@ async function buildAchievementHuntData(runtime2, input) {
           includeStats: false,
           recentUnlockedCount: input.recentUnlockedCount
         });
-        const summary = asRecord(getNestedValue(overview, "achievementSummary"));
-        const achievements = Array.isArray(overview.achievements) ? overview.achievements : Array.isArray(getNestedValue(overview, "achievements")) ? getNestedValue(overview, "achievements") : [];
+        const summary = asRecord(getNestedValue(overview, "summary"));
+        const appTarget = asRecord(getNestedValue(overview, "target", "app"));
+        const achievements = getRecordItems(getNestedValue(overview, "items"));
         const lockedAchievements = achievements.filter(
           (achievement) => toBoolean(achievement.achieved) !== true
         );
@@ -12854,7 +12917,8 @@ async function buildAchievementHuntData(runtime2, input) {
         return {
           ok: true,
           appid,
-          gameName: getStringValue(getNestedValue(overview, "game", "gameName")) ?? getStringValue(ownedGame?.name),
+          app: appTarget,
+          gameName: getStringValue(appTarget?.displayName) ?? getStringValue(appTarget?.name) ?? getStringValue(ownedGame?.name),
           playtimeForeverHours: toNumber(ownedGame?.playtimeForeverHours) ?? 0,
           playtimeForeverMinutes: toNumber(ownedGame?.playtimeForeverMinutes) ?? 0,
           hasCommunityVisibleStats: toBoolean(ownedGame?.hasCommunityVisibleStats),
@@ -12862,9 +12926,11 @@ async function buildAchievementHuntData(runtime2, input) {
           unlockedCount: toNumber(summary?.unlockedCount) ?? 0,
           lockedCount: toNumber(summary?.lockedCount) ?? 0,
           completionRate: toNumber(summary?.completionRate) ?? 0,
-          recentlyUnlocked: Array.isArray(summary?.recentlyUnlocked) ? summary?.recentlyUnlocked : [],
+          recentlyUnlocked: getRecordItems(
+            getNestedValue(overview, "sections", "recentlyUnlocked")
+          ),
           easiestRemaining,
-          warnings: Array.isArray(overview.warnings) ? overview.warnings : []
+          warnings: getWarnings(overview)
         };
       } catch (error) {
         return {
@@ -12875,39 +12941,37 @@ async function buildAchievementHuntData(runtime2, input) {
       }
     })
   );
-  const candidates = inspectedGames.filter((entry) => toBoolean(entry.ok) === true).filter(
+  const items = inspectedGames.filter((entry) => toBoolean(entry.ok) === true).filter(
     (entry) => (toNumber(entry.totalAchievements) ?? 0) > 0 && (toNumber(entry.completionRate) ?? 0) >= input.minCompletionRate && (toNumber(entry.lockedCount) ?? Number.MAX_SAFE_INTEGER) <= input.maxRemainingAchievements
   ).sort(compareAchievementHuntCandidates).slice(0, input.limit);
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    player: {
-      steamid: identity.steamid,
-      resolvedFrom: identity.resolvedFrom,
-      vanityUrl: identity.vanityUrl,
-      summary: normalizePlayerSummary(playerSummaryCall.data)
-    },
-    huntSummary: {
+    target: buildDefaultPlayerTarget(identity),
+    summary: {
       source: input.source,
       inspectedGameCount: inspectedGames.length,
-      candidateCount: candidates.length,
+      candidateCount: items.length,
       minCompletionRate: input.minCompletionRate,
       maxRemainingAchievements: input.maxRemainingAchievements
     },
-    candidates,
-    inspectedGames,
+    items,
+    sections: {
+      profile: normalizePlayerSummary(playerSummaryCall.data),
+      inspected: inspectedGames
+    },
     warnings: [
       ...runtime2.collectWarnings([playerSummaryCall, ownedGamesCall]),
       ...inspectedGames.flatMap((entry) => {
-        const record3 = asRecord(entry);
-        if (!record3) {
+        const record2 = asRecord(entry);
+        if (!record2) {
           return [];
         }
-        if (Array.isArray(record3.warnings)) {
-          return record3.warnings;
+        if (Array.isArray(record2.warnings)) {
+          return record2.warnings;
         }
-        if (typeof record3.error === "string") {
-          return [`appid ${record3.appid ?? "unknown"}: ${record3.error}`];
+        if (typeof record2.error === "string") {
+          return [`appid ${record2.appid ?? "unknown"}: ${record2.error}`];
         }
         return [];
       })
@@ -12952,9 +13016,9 @@ async function buildLibraryCompareData(runtime2, input) {
   const summaryMap = /* @__PURE__ */ new Map();
   for (const player of getNestedArray(summaryCall.data, "response", "players")) {
     const steamid = getStringValue(asRecord(player)?.steamid);
-    const record3 = normalizePlayerSummary({ response: { players: [player] } });
-    if (steamid && record3) {
-      summaryMap.set(steamid, record3);
+    const record2 = normalizePlayerSummary({ response: { players: [player] } });
+    if (steamid && record2) {
+      summaryMap.set(steamid, record2);
     }
   }
   const myOwnedGames = normalizeOwnedGames(myOwnedGamesCall.data).games;
@@ -13001,27 +13065,35 @@ async function buildLibraryCompareData(runtime2, input) {
   return {
     ok: true,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    me: {
-      steamid: myIdentity.steamid,
-      resolvedFrom: myIdentity.resolvedFrom,
-      vanityUrl: myIdentity.vanityUrl,
-      summary: summaryMap.get(myIdentity.steamid) ?? null,
-      gameCount: myOwnedGames.length
-    },
-    other: {
-      steamid: otherIdentity.steamid,
-      resolvedFrom: otherIdentity.resolvedFrom,
-      vanityUrl: otherIdentity.vanityUrl,
-      summary: summaryMap.get(otherIdentity.steamid) ?? null,
-      gameCount: otherOwnedGames.length
-    },
-    comparison: {
+    target: {
+      me: {
+        steamid: myIdentity.steamid,
+        resolvedFrom: myIdentity.resolvedFrom,
+        vanityUrl: myIdentity.vanityUrl
+      },
+      other: {
+        steamid: otherIdentity.steamid,
+        resolvedFrom: otherIdentity.resolvedFrom,
+        vanityUrl: otherIdentity.vanityUrl
+      }
+    },
+    summary: {
+      myGameCount: myOwnedGames.length,
+      otherGameCount: otherOwnedGames.length,
       sharedGameCount: sharedGames.length,
       overlapPercentOfMine: myOwnedGames.length > 0 ? roundTo(sharedGames.length / myOwnedGames.length * 100, 2) : 0,
-      overlapPercentOfOther: otherOwnedGames.length > 0 ? roundTo(sharedGames.length / otherOwnedGames.length * 100, 2) : 0,
-      topSharedGames: sharedGames.slice(0, input.includeSharedTop),
-      onlyMineSample: onlyMine.slice(0, input.includeOnlyMineSample),
-      onlyOtherSample: onlyOther.slice(0, input.includeOnlyOtherSample)
+      overlapPercentOfOther: otherOwnedGames.length > 0 ? roundTo(sharedGames.length / otherOwnedGames.length * 100, 2) : 0
+    },
+    sections: {
+      me: {
+        profile: summaryMap.get(myIdentity.steamid) ?? null
+      },
+      other: {
+        profile: summaryMap.get(otherIdentity.steamid) ?? null
+      },
+      sharedTop: sharedGames.slice(0, input.includeSharedTop),
+      onlyMine: onlyMine.slice(0, input.includeOnlyMineSample),
+      onlyOther: onlyOther.slice(0, input.includeOnlyOtherSample)
     },
     warnings: runtime2.collectWarnings([summaryCall, myOwnedGamesCall, otherOwnedGamesCall])
   };
@@ -13071,18 +13143,39 @@ async function selectAchievementHuntAppIds(runtime2, input) {
     ...input.explicitAppIds
   ])].slice(0, input.inspectCount);
 }
+function buildDefaultPlayerTarget(identity) {
+  return {
+    player: {
+      steamid: identity.steamid,
+      resolvedFrom: identity.resolvedFrom,
+      vanityUrl: identity.vanityUrl
+    }
+  };
+}
+function getWarnings(payload) {
+  const warnings = getNestedValue(payload, "warnings");
+  return Array.isArray(warnings) ? warnings : [];
+}
+function getRecord(value) {
+  return asRecord(value);
+}
+function getRecordItems(value) {
+  return Array.isArray(value) ? value.map((entry) => asRecord(entry)).filter((entry) => Boolean(entry)) : [];
+}
 
 // src/tools/me.ts
 function registerMyAccountTools(server, runtime2) {
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_profile",
     {
-      title: "\u6211\u7684 Steam \u8D44\u6599",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684 Steam \u8D44\u6599\u603B\u89C8\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        includeRecentlyPlayed: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        recentGamesCount: z4.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 3\u3002")
+        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"),
+        recentGamesCount: z3.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 3\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13090,32 +13183,29 @@ function registerMyAccountTools(server, runtime2) {
       }
     },
     async ({ key, includeRecentlyPlayed = true, recentGamesCount = 3 }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_profile");
-        const payload = await buildPlayerProfileOverviewData(runtime2, {
-          toolName: "steam_me_profile",
-          key,
-          includeRecentlyPlayed,
-          recentGamesCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_profile", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_profile");
+      return buildPlayerProfileOverviewData(runtime2, {
+        toolName: "steam_me_profile",
+        key,
+        includeRecentlyPlayed,
+        recentGamesCount
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_library",
     {
-      title: "\u6211\u7684 Steam \u6E38\u620F\u5E93",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u6E38\u620F\u5E93\u603B\u89C8\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        includeAppInfo: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6E38\u620F\u540D\u79F0\u548C\u56FE\u6807\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includePlayedFreeGames: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u73A9\u8FC7\u7684\u514D\u8D39\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeRecentGames: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        recentGamesCount: z4.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 5\u3002"),
-        topGamesCount: z4.number().int().min(1).max(50).optional().describe("\u6309\u6E38\u73A9\u65F6\u957F\u6392\u5E8F\u8FD4\u56DE\u524D\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 10\u3002")
+        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"),
+        includePlayedFreeGames: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u73A9\u8FC7\u7684\u514D\u8D39\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeRecentGames: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\uFF0C\u9ED8\u8BA4 true\u3002"),
+        recentGamesCount: z3.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 5\u3002"),
+        topGamesCount: z3.number().int().min(1).max(50).optional().describe("\u6309\u65F6\u957F\u6392\u5E8F\u8FD4\u56DE\u524D\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 10\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13130,31 +13220,28 @@ function registerMyAccountTools(server, runtime2) {
       recentGamesCount = 5,
       topGamesCount = 10
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_library");
-        const payload = await buildLibraryOverviewData(runtime2, {
-          toolName: "steam_me_library",
-          key,
-          includeAppInfo,
-          includePlayedFreeGames,
-          includeRecentGames,
-          recentGamesCount,
-          topGamesCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_library", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_library");
+      return buildLibraryOverviewData(runtime2, {
+        toolName: "steam_me_library",
+        key,
+        includeAppInfo,
+        includePlayedFreeGames,
+        includeRecentGames,
+        recentGamesCount,
+        topGamesCount
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_recently_played",
     {
       title: "\u6211\u7684\u6700\u8FD1\u6E38\u73A9",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u3002",
+      description: "\u9ED8\u8BA4\u8D26\u53F7\u5FEB\u6377\u5165\u53E3\uFF0C\u67E5\u770B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\u3002",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        count: z4.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002")
+        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")
       },
       annotations: {
         readOnlyHint: true,
@@ -13162,26 +13249,23 @@ function registerMyAccountTools(server, runtime2) {
       }
     },
     async ({ key, count = 10 }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_recently_played");
-        const payload = await buildRecentlyPlayedData(runtime2, {
-          toolName: "steam_me_recently_played",
-          key,
-          count
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_recently_played", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_recently_played");
+      return buildRecentlyPlayedData(runtime2, {
+        toolName: "steam_me_recently_played",
+        key,
+        count
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_badges",
     {
-      title: "\u6211\u7684 Steam \u5FBD\u7AE0",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u7B49\u7EA7\u548C\u5FBD\u7AE0\u4FE1\u606F\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
+        key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13189,29 +13273,27 @@ function registerMyAccountTools(server, runtime2) {
       }
     },
     async ({ key }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_badges");
-        const payload = await buildBadgesOverviewData(runtime2, {
-          toolName: "steam_me_badges",
-          key
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_badges", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_badges");
+      return buildBadgesOverviewData(runtime2, {
+        toolName: "steam_me_badges",
+        key
+      });
     }
   );
-  server.registerTool(
-    "steam_me_achievement_overview",
+  registerSteamTool(
+    server,
+    runtime2,
+    "steam_me_game_achievements",
     {
-      title: "\u6211\u7684 Steam \u6210\u5C31\u603B\u89C8",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u5728\u67D0\u4E2A\u6E38\u620F\u4E2D\u7684\u6210\u5C31\u603B\u89C8\u3002",
+      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",
       inputSchema: {
-        appid: z4.union([z4.string(), z4.number()]).describe("\u8981\u67E5\u770B\u7684 Steam AppID\u3002"),
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        language: z4.string().optional().describe("\u53EF\u9009\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 'schinese' \u6216 'english'\u3002"),
-        includeStats: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u8BE5\u6E38\u620F\u7684\u73A9\u5BB6\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
-        recentUnlockedCount: z4.number().int().min(1).max(50).optional().describe("\u9AD8\u4EAE\u5C55\u793A\u6700\u8FD1\u89E3\u9501\u6210\u5C31\u7684\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002")
+        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"),
+        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"),
+        includeStats: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u73A9\u5BB6\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
+        recentUnlockedCount: z3.number().int().min(1).max(50).optional().describe("\u6700\u8FD1\u89E3\u9501\u6210\u5C31\u7684\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13220,38 +13302,37 @@ function registerMyAccountTools(server, runtime2) {
     },
     async ({
       appid,
+      query,
       key,
       language,
       includeStats = true,
       recentUnlockedCount = 10
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_achievement_overview");
-        const payload = await buildAchievementOverviewData(runtime2, {
-          toolName: "steam_me_achievement_overview",
-          appid,
-          key,
-          language,
-          includeStats,
-          recentUnlockedCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_achievement_overview", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_game_achievements");
+      return buildPlayerGameAchievementsData(runtime2, {
+        toolName: "steam_me_game_achievements",
+        appid,
+        query,
+        key,
+        language,
+        includeStats,
+        recentUnlockedCount
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_friends",
     {
-      title: "\u6211\u7684 Steam \u597D\u53CB",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u597D\u53CB\u5217\u8868\uFF0C\u5E76\u53EF\u9009\u9644\u5E26\u8D44\u6599\u8865\u5145\u4FE1\u606F\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        relationship: z4.string().optional().describe("\u597D\u53CB\u5173\u7CFB\u8FC7\u6EE4\u6761\u4EF6\uFF0C\u9ED8\u8BA4 'friend'\u3002"),
-        includeSummaries: z4.boolean().optional().describe("\u662F\u5426\u4E3A\u597D\u53CB\u8865\u5145\u8D44\u6599\u6458\u8981\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeBans: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u597D\u53CB\u5C01\u7981\u6458\u8981\uFF0C\u9ED8\u8BA4 false\u3002"),
-        limit: z4.number().int().min(1).max(500).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4F4D\u597D\u53CB\uFF0C\u9ED8\u8BA4 100\u3002")
+        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"),
+        includeSummaries: z3.boolean().optional().describe("\u662F\u5426\u8865\u5145\u597D\u53CB\u8D44\u6599\u6458\u8981\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeBans: z3.boolean().optional().describe("\u662F\u5426\u8865\u5145\u597D\u53CB\u5C01\u7981\u6458\u8981\uFF0C\u9ED8\u8BA4 false\u3002"),
+        limit: z3.number().int().min(1).max(500).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4F4D\u597D\u53CB\uFF0C\u9ED8\u8BA4 100\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13265,32 +13346,29 @@ function registerMyAccountTools(server, runtime2) {
       includeBans = false,
       limit = 100
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_friends");
-        const payload = await buildFriendsData(runtime2, {
-          toolName: "steam_me_friends",
-          key,
-          relationship,
-          includeSummaries,
-          includeBans,
-          limit
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_friends", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_friends");
+      return buildFriendsData(runtime2, {
+        toolName: "steam_me_friends",
+        key,
+        relationship,
+        includeSummaries,
+        includeBans,
+        limit
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_friend_activity",
     {
-      title: "\u6211\u7684\u597D\u53CB\u52A8\u6001",
-      description: "\u7A81\u51FA\u663E\u793A\u54EA\u4E9B\u597D\u53CB\u6B63\u5728\u6E38\u620F\u3001\u5728\u7EBF\uFF0C\u6216\u6700\u8FD1\u6D3B\u8DC3\u8FC7\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        limit: z4.number().int().min(1).max(500).optional().describe("\u6700\u591A\u68C0\u67E5\u591A\u5C11\u4F4D\u597D\u53CB\uFF0C\u9ED8\u8BA4 100\u3002"),
-        onlyInGame: z4.boolean().optional().describe("\u662F\u5426\u53EA\u8FD4\u56DE\u5F53\u524D\u6B63\u5728\u6E38\u620F\u7684\u597D\u53CB\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeBans: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u8FD4\u56DE\u597D\u53CB\u7684\u5C01\u7981\u6458\u8981\uFF0C\u9ED8\u8BA4 false\u3002")
+        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"),
+        onlyInGame: z3.boolean().optional().describe("\u662F\u5426\u53EA\u8FD4\u56DE\u6B63\u5728\u6E38\u620F\u4E2D\u7684\u597D\u53CB\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeBans: z3.boolean().optional().describe("\u662F\u5426\u8865\u5145\u597D\u53CB\u5C01\u7981\u6458\u8981\uFF0C\u9ED8\u8BA4 false\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13298,39 +13376,37 @@ function registerMyAccountTools(server, runtime2) {
       }
     },
     async ({ key, limit = 100, onlyInGame = false, includeBans = false }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_friend_activity");
-        const payload = await buildFriendActivityData(runtime2, {
-          toolName: "steam_me_friend_activity",
-          key,
-          limit,
-          onlyInGame,
-          includeBans
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_friend_activity", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_friend_activity");
+      return buildFriendActivityData(runtime2, {
+        toolName: "steam_me_friend_activity",
+        key,
+        limit,
+        onlyInGame,
+        includeBans
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_friend_network",
     {
-      title: "\u6211\u7684\u597D\u53CB\u7F51\u7EDC",
-      description: "\u4E3A\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u751F\u6210\u597D\u53CB\u7F51\u7EDC\u89C6\u56FE\uFF0C\u5305\u542B\u6D3B\u52A8\u5206\u7EC4\u548C\u9002\u5408\u56FE\u8C31\u5C55\u793A\u7684 nodes/edges\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        limit: z4.number().int().min(1).max(500).optional().describe("\u6700\u591A\u68C0\u67E5\u591A\u5C11\u4F4D\u597D\u53CB\uFF0C\u9ED8\u8BA4 150\u3002"),
-        activityWindowHours: z4.number().int().min(1).max(720).optional().describe("\u591A\u5C11\u5C0F\u65F6\u5185\u7B97\u201C\u6700\u8FD1\u6D3B\u8DC3\u201D\uFF0C\u9ED8\u8BA4 72\u3002"),
-        includeBans: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u8FD4\u56DE\u597D\u53CB\u7684\u5C01\u7981\u6458\u8981\uFF0C\u9ED8\u8BA4 false\u3002"),
-        includeGraph: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u9002\u5408\u56FE\u8C31\u6E32\u67D3\u7684 nodes \u548C edges\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeGameNodes: z4.boolean().optional().describe("\u56FE\u8C31\u8F93\u51FA\u4E2D\u662F\u5426\u5305\u542B\u5F53\u524D\u6B63\u5728\u73A9\u7684\u6E38\u620F\u8282\u70B9\uFF0C\u9ED8\u8BA4 true\u3002")
+        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"),
+        activityWindowHours: z3.number().int().min(1).max(720).optional().describe("\u591A\u5C11\u5C0F\u65F6\u5185\u7B97\u6700\u8FD1\u6D3B\u8DC3\uFF0C\u9ED8\u8BA4 72\u3002"),
+        includeBans: z3.boolean().optional().describe("\u662F\u5426\u8865\u5145\u597D\u53CB\u5C01\u7981\u6458\u8981\uFF0C\u9ED8\u8BA4 false\u3002"),
+        includeGraph: z3.boolean().optional().describe("\u662F\u5426\u8FD4\u56DE\u53EF\u89C6\u5316 graph\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeGameNodes: z3.boolean().optional().describe("graph \u4E2D\u662F\u5426\u5305\u542B\u6E38\u620F\u8282\u70B9\uFF0C\u9ED8\u8BA4 true\u3002")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: false
       }
     },
+    // 好友网络不是另一个数据源，而是对好友列表做更高层的关系视图整理。
     async ({
       key,
       limit = 150,
@@ -13339,30 +13415,27 @@ function registerMyAccountTools(server, runtime2) {
       includeGraph = true,
       includeGameNodes = true
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_friend_network");
-        const payload = await buildFriendNetworkData(runtime2, {
-          toolName: "steam_me_friend_network",
-          key,
-          limit,
-          activityWindowHours,
-          includeBans,
-          includeGraph,
-          includeGameNodes
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_friend_network", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_friend_network");
+      return buildFriendNetworkData(runtime2, {
+        toolName: "steam_me_friend_network",
+        key,
+        limit,
+        activityWindowHours,
+        includeBans,
+        includeGraph,
+        includeGameNodes
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_bans",
     {
-      title: "\u6211\u7684\u5C01\u7981\u72B6\u6001",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u5C01\u7981\u6458\u8981\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
+        key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13370,34 +13443,31 @@ function registerMyAccountTools(server, runtime2) {
       }
     },
     async ({ key }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_bans");
-        const payload = await buildBansData(runtime2, {
-          toolName: "steam_me_bans",
-          key
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_bans", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_bans");
+      return buildBansData(runtime2, {
+        toolName: "steam_me_bans",
+        key
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_library_compare",
     {
-      title: "\u6211\u7684\u6E38\u620F\u5E93\u5BF9\u6BD4",
-      description: "\u628A\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u6E38\u620F\u5E93\u4E0E\u53E6\u4E00\u4F4D\u73A9\u5BB6\u8FDB\u884C\u5BF9\u6BD4\u3002",
+      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",
       inputSchema: {
-        steamid: z4.union([z4.string(), z4.number()]).optional().describe("\u5BF9\u65B9\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\u3002"),
-        vanityUrl: z4.string().optional().describe("\u5BF9\u65B9\u73A9\u5BB6\u7684 Steam \u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\u3002\u4E0E steamid \u4E8C\u9009\u4E00\u3002"),
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        includeOnlyMineSample: z4.number().int().min(1).max(50).optional().describe("\u4F60\u7684\u5E93\u4E2D\u72EC\u6709\u6E38\u620F\u91C7\u6837\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002"),
-        includeOnlyOtherSample: z4.number().int().min(1).max(50).optional().describe("\u5BF9\u65B9\u5E93\u4E2D\u72EC\u6709\u6E38\u620F\u91C7\u6837\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002"),
-        includeSharedTop: z4.number().int().min(1).max(50).optional().describe("\u5171\u540C\u62E5\u6709\u6E38\u620F\u91CC\u6309\u603B\u6E38\u73A9\u65F6\u957F\u9AD8\u4EAE\u591A\u5C11\u4E2A\uFF0C\u9ED8\u8BA4 20\u3002")
+        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"),
+        key: z3.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
+        includeOnlyMineSample: z3.number().int().min(0).max(50).optional().describe("\u6211\u7684\u72EC\u6709\u6E38\u620F\u91C7\u6837\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002"),
+        includeOnlyOtherSample: z3.number().int().min(0).max(50).optional().describe("\u5BF9\u65B9\u72EC\u6709\u6E38\u620F\u91C7\u6837\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002"),
+        includeSharedTop: z3.number().int().min(1).max(50).optional().describe("\u5171\u540C\u62E5\u6709\u6E38\u620F\u4E2D\u6309\u603B\u65F6\u957F\u9AD8\u4EAE\u591A\u5C11\u4E2A\uFF0C\u9ED8\u8BA4 20\u3002")
       },
       annotations: {
         readOnlyHint: true,
-        openWorldHint: true
+        openWorldHint: false
       }
     },
     async ({
@@ -13408,36 +13478,33 @@ function registerMyAccountTools(server, runtime2) {
       includeOnlyOtherSample = 10,
       includeSharedTop = 20
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_library_compare");
-        const payload = await buildLibraryCompareData(runtime2, {
-          toolName: "steam_me_library_compare",
-          steamid,
-          vanityUrl,
-          key,
-          includeOnlyMineSample,
-          includeOnlyOtherSample,
-          includeSharedTop
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_library_compare", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_library_compare");
+      return buildLibraryCompareData(runtime2, {
+        toolName: "steam_me_library_compare",
+        steamid,
+        vanityUrl,
+        key,
+        includeOnlyMineSample,
+        includeOnlyOtherSample,
+        includeSharedTop
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_backlog_candidates",
     {
-      title: "\u6211\u7684\u79EF\u538B\u6E38\u620F\u5019\u9009",
-      description: "\u4ECE\u5DF2\u62E5\u6709\u6E38\u620F\u91CC\u627E\u51FA\u51E0\u4E4E\u6CA1\u73A9\u6216\u8FD8\u6CA1\u5F00\u59CB\u7684\u5019\u9009\uFF0C\u5E76\u53EF\u9009\u9644\u5E26\u70ED\u5EA6\u548C\u65B0\u95FB\u4FE1\u53F7\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        limit: z4.number().int().min(1).max(30).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u79EF\u538B\u5019\u9009\uFF0C\u9ED8\u8BA4 12\u3002"),
-        maxPlaytimeHours: z4.number().min(0).max(20).optional().describe("\u53EA\u5305\u542B\u6E38\u73A9\u65F6\u957F\u4E0D\u8D85\u8FC7\u8BE5\u5C0F\u65F6\u6570\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 2\u3002"),
-        minDaysSinceLastPlayed: z4.number().int().min(0).max(3650).optional().describe("\u53EA\u5305\u542B\u81F3\u5C11\u8FD9\u4E48\u591A\u5929\u6CA1\u6709\u6E38\u73A9\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 30\u3002"),
-        includeCurrentPlayers: z4.boolean().optional().describe("\u662F\u5426\u4E3A\u5019\u9009\u6E38\u620F\u9644\u5E26\u5F53\u524D\u5168\u7403\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeNews: z4.boolean().optional().describe("\u662F\u5426\u4E3A\u5019\u9009\u6E38\u620F\u9644\u5E26\u4E00\u6761\u6700\u8FD1\u65B0\u95FB\uFF0C\u9ED8\u8BA4 false\u3002"),
-        preferCommunityVisibleStats: z4.boolean().optional().describe("\u662F\u5426\u8BA9\u5E26\u793E\u533A\u53EF\u89C1\u7EDF\u8BA1\u7684\u6E38\u620F\u83B7\u5F97\u66F4\u9AD8\u6392\u5E8F\u6743\u91CD\uFF0C\u9ED8\u8BA4 true\u3002")
+        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"),
+        maxPlaytimeHours: z3.number().min(0).max(200).optional().describe("\u53EA\u5305\u542B\u6E38\u73A9\u65F6\u957F\u4E0D\u8D85\u8FC7\u8BE5\u5C0F\u65F6\u6570\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 2\u3002"),
+        minDaysSinceLastPlayed: z3.number().int().min(0).max(3650).optional().describe("\u53EA\u5305\u542B\u81F3\u5C11\u8FD9\u4E48\u591A\u5929\u6CA1\u73A9\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 30\u3002"),
+        includeCurrentPlayers: z3.boolean().optional().describe("\u662F\u5426\u8865\u5145\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeNews: z3.boolean().optional().describe("\u662F\u5426\u8865\u5145\u4E00\u6761\u6700\u8FD1\u65B0\u95FB\uFF0C\u9ED8\u8BA4 false\u3002"),
+        preferCommunityVisibleStats: z3.boolean().optional().describe("\u662F\u5426\u4F18\u5148\u6709\u793E\u533A\u7EDF\u8BA1\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13453,43 +13520,36 @@ function registerMyAccountTools(server, runtime2) {
       includeNews = false,
       preferCommunityVisibleStats = true
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_backlog_candidates");
-        const payload = await buildBacklogCandidatesData(runtime2, {
-          toolName: "steam_me_backlog_candidates",
-          key,
-          limit,
-          maxPlaytimeHours,
-          minDaysSinceLastPlayed,
-          includeCurrentPlayers,
-          includeNews,
-          preferCommunityVisibleStats
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_backlog_candidates", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_backlog_candidates");
+      return buildBacklogCandidatesData(runtime2, {
+        toolName: "steam_me_backlog_candidates",
+        key,
+        limit,
+        maxPlaytimeHours,
+        minDaysSinceLastPlayed,
+        includeCurrentPlayers,
+        includeNews,
+        preferCommunityVisibleStats
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_achievement_hunt",
     {
-      title: "\u6211\u7684\u6210\u5C31\u72E9\u730E",
-      description: "\u4ECE\u4F60\u7684\u6E38\u620F\u5E93\u91CC\u6311\u51FA\u6700\u63A5\u8FD1\u5168\u6210\u5C31\u5B8C\u6210\u7684\u5019\u9009\u6E38\u620F\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        language: z4.string().optional().describe("\u53EF\u9009\u7684\u6210\u5C31 schema \u8BED\u8A00\u4EE3\u7801\u3002"),
-        source: z4.enum(["recent", "topOwned", "mixed", "explicit"]).optional().describe("\u5982\u4F55\u9009\u62E9\u8981\u68C0\u67E5\u7684\u6E38\u620F\u6765\u6E90\uFF0C\u9ED8\u8BA4 'mixed'\u3002"),
-        appids: z4.union([
-          z4.string(),
-          z4.number(),
-          z4.array(z4.union([z4.string(), z4.number()]))
-        ]).optional().describe("\u663E\u5F0F\u6307\u5B9A\u8981\u68C0\u67E5\u7684 AppID\uFF1B\u5F53 source \u4E3A 'explicit' \u65F6\u5FC5\u586B\u3002"),
-        inspectCount: z4.number().int().min(1).max(30).optional().describe("\u5728\u7B5B\u9009\u524D\u6700\u591A\u68C0\u67E5\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 12\u3002"),
-        limit: z4.number().int().min(1).max(20).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u6210\u5C31\u72E9\u730E\u5019\u9009\uFF0C\u9ED8\u8BA4 8\u3002"),
-        minCompletionRate: z4.number().min(0).max(100).optional().describe("\u53EA\u5305\u542B\u5B8C\u6210\u7387\u4E0D\u4F4E\u4E8E\u8BE5\u503C\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 50\u3002"),
-        maxRemainingAchievements: z4.number().int().min(0).max(200).optional().describe("\u53EA\u5305\u542B\u5269\u4F59\u672A\u89E3\u9501\u6210\u5C31\u4E0D\u8D85\u8FC7\u8BE5\u6570\u91CF\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 20\u3002"),
-        recentUnlockedCount: z4.number().int().min(1).max(20).optional().describe("\u6BCF\u4E2A\u6E38\u620F\u4FDD\u7559\u591A\u5C11\u6761\u6700\u8FD1\u89E3\u9501\u6210\u5C31\uFF0C\u9ED8\u8BA4 5\u3002")
+        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"),
+        source: z3.enum(["recent", "topOwned", "mixed", "explicit"]).optional().describe("\u9009\u62E9\u8981\u68C0\u67E5\u7684\u6E38\u620F\u6765\u6E90\uFF0C\u9ED8\u8BA4 mixed\u3002"),
+        appids: z3.union([z3.string(), z3.number(), z3.array(z3.union([z3.string(), z3.number()]))]).optional().describe("\u663E\u5F0F\u6307\u5B9A\u8981\u68C0\u67E5\u7684 AppID\uFF1B\u5F53 source=explicit \u65F6\u4F7F\u7528\u3002"),
+        inspectCount: z3.number().int().min(1).max(50).optional().describe("\u7B5B\u9009\u524D\u6700\u591A\u68C0\u67E5\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 12\u3002"),
+        limit: z3.number().int().min(1).max(20).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u4E2A\u5019\u9009\uFF0C\u9ED8\u8BA4 8\u3002"),
+        minCompletionRate: z3.number().min(0).max(100).optional().describe("\u53EA\u5305\u542B\u5B8C\u6210\u7387\u4E0D\u4F4E\u4E8E\u8BE5\u503C\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 50\u3002"),
+        maxRemainingAchievements: z3.number().int().min(0).max(200).optional().describe("\u53EA\u5305\u542B\u5269\u4F59\u672A\u89E3\u9501\u6210\u5C31\u4E0D\u8D85\u8FC7\u8BE5\u6570\u91CF\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 20\u3002"),
+        recentUnlockedCount: z3.number().int().min(1).max(50).optional().describe("\u6700\u8FD1\u89E3\u9501\u6210\u5C31\u7684\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 5\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13507,49 +13567,49 @@ function registerMyAccountTools(server, runtime2) {
       maxRemainingAchievements = 20,
       recentUnlockedCount = 5
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_achievement_hunt");
-        const payload = await buildAchievementHuntData(runtime2, {
-          toolName: "steam_me_achievement_hunt",
-          key,
-          language,
-          source,
-          appids,
-          inspectCount,
-          limit,
-          minCompletionRate,
-          maxRemainingAchievements,
-          recentUnlockedCount
-        });
-        return runtime2.createJsonToolResult(payload, payload.ok === false);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_achievement_hunt", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_achievement_hunt");
+      return buildAchievementHuntData(runtime2, {
+        toolName: "steam_me_achievement_hunt",
+        key,
+        language,
+        source,
+        appids,
+        inspectCount,
+        limit,
+        minCompletionRate,
+        maxRemainingAchievements,
+        recentUnlockedCount
+      });
     }
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_me_game_snapshot",
     {
       title: "\u6211\u7684\u6E38\u620F\u5FEB\u7167",
-      description: "\u9488\u5BF9\u5355\u4E2A AppID \u805A\u5408\u6211\u662F\u5426\u62E5\u6709\u3001\u6E38\u73A9\u65F6\u957F\u3001\u6210\u5C31\u3001\u7EDF\u8BA1\u3001\u65B0\u95FB\u548C\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\u3002",
+      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",
       inputSchema: {
-        appid: z4.union([z4.string(), z4.number()]).describe("\u8981\u67E5\u770B\u7684 Steam AppID\u3002"),
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        language: z4.string().optional().describe("\u53EF\u9009\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 'schinese' \u6216 'english'\u3002"),
-        includeAchievements: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u4E2A\u4EBA\u6210\u5C31\u660E\u7EC6\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeStats: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u4E2A\u4EBA\u6E38\u620F\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeNews: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1 Steam \u65B0\u95FB\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includePlayerCount: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5F53\u524D\u5168\u7403\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
-        newsCount: z4.number().int().min(1).max(10).optional().describe("\u8FD4\u56DE\u591A\u5C11\u6761\u65B0\u95FB\uFF0C\u9ED8\u8BA4 3\u3002"),
-        newsMaxLength: z4.number().int().min(0).max(1e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u5185\u5BB9\u7684\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 180\u3002")
+        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"),
+        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"),
+        includeAchievements: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u4E2A\u4EBA\u6210\u5C31\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeStats: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u4E2A\u4EBA\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeNews: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u65B0\u95FB\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includePlayerCount: z3.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
+        newsCount: z3.number().int().min(1).max(10).optional().describe("\u65B0\u95FB\u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 3\u3002"),
+        newsMaxLength: z3.number().int().min(0).max(5e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 180\u3002")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: false
       }
     },
+    // 个人单游戏主入口；需要更窄的数据时再走成就或动态等专项工具。
     async ({
       appid,
+      query,
       key,
       language,
       includeAchievements = true,
@@ -13559,76 +13619,45 @@ function registerMyAccountTools(server, runtime2) {
       newsCount = 3,
       newsMaxLength = 180
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_game_snapshot");
-        const payload = await buildGameSnapshotData(runtime2, {
-          toolName: "steam_me_game_snapshot",
-          appid,
-          key,
-          language,
-          includeAchievements,
-          includeStats,
-          includeNews,
-          includePlayerCount,
-          newsCount,
-          newsMaxLength
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_game_snapshot", error);
-      }
-    }
-  );
-  server.registerTool(
-    "steam_me_groups",
-    {
-      title: "\u6211\u7684 Steam \u7FA4\u7EC4",
-      description: "\u5FEB\u6377\u67E5\u770B\u5DF2\u914D\u7F6E\u9ED8\u8BA4\u8D26\u53F7\u7684\u7FA4\u7EC4\u5217\u8868\u3002\u6CE8\u610F\uFF1ASteam \u6587\u6863\u628A\u5E95\u5C42\u63A5\u53E3\u6807\u8BB0\u4E3A publisher-key-only\u3002",
-      inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002")
-      },
-      annotations: {
-        readOnlyHint: true,
-        openWorldHint: false
-      }
-    },
-    async ({ key }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_groups");
-        const payload = await buildGroupsData(runtime2, {
-          toolName: "steam_me_groups",
-          key
-        });
-        return runtime2.createJsonToolResult(payload, payload.ok === false);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_groups", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_game_snapshot");
+      return buildGameSnapshotData(runtime2, {
+        toolName: "steam_me_game_snapshot",
+        appid,
+        query,
+        key,
+        language,
+        includeAchievements,
+        includeStats,
+        includeNews,
+        includePlayerCount,
+        newsCount,
+        newsMaxLength
+      });
     }
   );
-  server.registerTool(
-    "steam_me_wishlist_like_feed",
+  registerSteamTool(
+    server,
+    runtime2,
+    "steam_me_game_feed",
     {
-      title: "\u6211\u7684 Steam \u5173\u6CE8\u6D41",
-      description: "\u4EE5\u5173\u6CE8\u6D41\u7684\u5F62\u5F0F\u67E5\u770B\u4F60\u6700\u8FD1\u73A9\u8FC7\u6216\u5173\u5FC3\u7684\u5E94\u7528\uFF0C\u9ED8\u8BA4\u6309\u6700\u8FD1\u6E38\u73A9\u7684 AppID \u805A\u5408\u65B0\u95FB\u548C\u70ED\u5EA6\u3002",
+      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",
       inputSchema: {
-        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        source: z4.enum(["recent", "topOwned", "mixed", "explicit"]).optional().describe("\u5982\u4F55\u4E3A\u5173\u6CE8\u6D41\u9009\u62E9\u5E94\u7528\u6765\u6E90\uFF0C\u9ED8\u8BA4 'recent'\u3002"),
-        appids: z4.union([
-          z4.string(),
-          z4.number(),
-          z4.array(z4.union([z4.string(), z4.number()]))
-        ]).optional().describe("\u663E\u5F0F\u6307\u5B9A\u8981\u5173\u6CE8\u7684 appid\uFF1B\u5F53 source \u4E3A 'explicit' \u65F6\u5FC5\u586B\u3002"),
-        limitApps: z4.number().int().min(1).max(20).optional().describe("\u6700\u591A\u5305\u542B\u591A\u5C11\u4E2A\u5E94\u7528\uFF0C\u9ED8\u8BA4 5\u3002"),
-        newsPerApp: z4.number().int().min(1).max(10).optional().describe("\u6BCF\u4E2A\u5E94\u7528\u6293\u53D6\u591A\u5C11\u6761\u65B0\u95FB\uFF0C\u9ED8\u8BA4 2\u3002"),
-        newsMaxLength: z4.number().int().min(0).max(500).optional().describe("\u6BCF\u6761\u65B0\u95FB\u5185\u5BB9\u7684\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 160\u3002"),
-        includePlayerCount: z4.boolean().optional().describe("\u662F\u5426\u4E3A\u6BCF\u4E2A\u5E94\u7528\u9644\u5E26\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeOwnedContext: z4.boolean().optional().describe("\u662F\u5426\u9644\u5E26\u4F60\u662F\u5426\u62E5\u6709\u8BE5\u5E94\u7528\u4EE5\u53CA\u4F60\u7684\u6E38\u73A9\u65F6\u957F\uFF0C\u9ED8\u8BA4 true\u3002")
+        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"),
+        appids: z3.union([z3.string(), z3.number(), z3.array(z3.union([z3.string(), z3.number()]))]).optional().describe("\u663E\u5F0F\u6307\u5B9A AppID\uFF1B\u5F53 source=explicit \u65F6\u4F7F\u7528\u3002"),
+        limitApps: z3.number().int().min(1).max(20).optional().describe("\u6700\u591A\u5305\u542B\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 5\u3002"),
+        newsPerApp: z3.number().int().min(1).max(10).optional().describe("\u6BCF\u4E2A\u6E38\u620F\u6293\u53D6\u591A\u5C11\u6761\u65B0\u95FB\uFF0C\u9ED8\u8BA4 2\u3002"),
+        newsMaxLength: z3.number().int().min(0).max(5e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 160\u3002"),
+        includePlayerCount: z3.boolean().optional().describe("\u662F\u5426\u9644\u5E26\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeOwnedContext: z3.boolean().optional().describe("\u662F\u5426\u9644\u5E26\u6211\u662F\u5426\u62E5\u6709\u548C\u6E38\u73A9\u65F6\u957F\uFF0C\u9ED8\u8BA4 true\u3002")
       },
       annotations: {
         readOnlyHint: true,
         openWorldHint: false
       }
     },
+    // feed 只描述“我的游戏动态流”，不再暗示真实 wishlist 数据源。
     async ({
       key,
       source = "recent",
@@ -13639,41 +13668,38 @@ function registerMyAccountTools(server, runtime2) {
       includePlayerCount = true,
       includeOwnedContext = true
     }) => {
-      try {
-        runtime2.requireConfiguredDefaultIdentity("steam_me_wishlist_like_feed");
-        const payload = await buildWishlistLikeFeedData(runtime2, {
-          toolName: "steam_me_wishlist_like_feed",
-          key,
-          source,
-          appids,
-          limitApps,
-          newsPerApp,
-          newsMaxLength,
-          includePlayerCount,
-          includeOwnedContext
-        });
-        return runtime2.createJsonToolResult(payload, payload.ok === false);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_me_wishlist_like_feed", error);
-      }
+      runtime2.requireConfiguredDefaultIdentity("steam_me_game_feed");
+      return buildGameFeedData(runtime2, {
+        toolName: "steam_me_game_feed",
+        key,
+        source,
+        appids,
+        limitApps,
+        newsPerApp,
+        newsMaxLength,
+        includePlayerCount,
+        includeOwnedContext
+      });
     }
   );
 }
 
 // src/tools/overview.ts
-import * as z5 from "zod/v4";
+import * as z4 from "zod/v4";
 function registerOverviewTools(server, runtime2) {
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_get_player_profile_overview",
     {
-      title: "Steam \u73A9\u5BB6\u8D44\u6599\u603B\u89C8",
-      description: "\u805A\u5408\u73A9\u5BB6\u7684 Steam \u8D44\u6599\u3001\u5C01\u7981\u72B6\u6001\u3001\u7B49\u7EA7\u3001\u5FBD\u7AE0\u548C\u6700\u8FD1\u6E38\u73A9\u4FE1\u606F\u3002",
+      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",
       inputSchema: {
-        steamid: z5.union([z5.string(), z5.number()]).optional().describe("\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\uFF1B\u82E5\u90FD\u4E0D\u4F20\u4E14\u5DF2\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528\u8BE5\u503C\u3002"),
-        vanityUrl: z5.string().optional().describe("\u73A9\u5BB6\u7684 Steam \u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\uFF0C\u4F8B\u5982 'gaben'\u3002\u4E0E steamid \u4E8C\u9009\u4E00\uFF1B\u82E5\u90FD\u4E0D\u4F20\u4E14\u5DF2\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528\u8BE5\u503C\u3002"),
-        key: z5.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        includeRecentlyPlayed: z5.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        recentGamesCount: z5.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 3\u3002")
+        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"),
+        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
+        includeRecentlyPlayed: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\u6570\u636E\uFF0C\u9ED8\u8BA4 true\u3002"),
+        recentGamesCount: z4.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 3\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13686,39 +13712,31 @@ function registerOverviewTools(server, runtime2) {
       key,
       includeRecentlyPlayed = true,
       recentGamesCount = 3
-    }) => {
-      try {
-        const payload = await buildPlayerProfileOverviewData(runtime2, {
-          toolName: "steam_get_player_profile_overview",
-          steamid,
-          vanityUrl,
-          key,
-          includeRecentlyPlayed,
-          recentGamesCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult(
-          "steam_get_player_profile_overview",
-          error
-        );
-      }
-    }
+    }) => buildPlayerProfileOverviewData(runtime2, {
+      toolName: "steam_get_player_profile_overview",
+      steamid,
+      vanityUrl,
+      key,
+      includeRecentlyPlayed,
+      recentGamesCount
+    })
   );
-  server.registerTool(
+  registerSteamTool(
+    server,
+    runtime2,
     "steam_get_library_overview",
     {
-      title: "Steam \u6E38\u620F\u5E93\u603B\u89C8",
-      description: "\u805A\u5408\u73A9\u5BB6\u62E5\u6709\u7684\u6E38\u620F\u3001\u6700\u8FD1\u6D3B\u52A8\u548C\u6309\u65F6\u957F\u6392\u5E8F\u7684\u5E38\u73A9\u6E38\u620F\u3002",
+      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",
       inputSchema: {
-        steamid: z5.union([z5.string(), z5.number()]).optional().describe("\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\uFF1B\u82E5\u90FD\u4E0D\u4F20\u4E14\u5DF2\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528\u8BE5\u503C\u3002"),
-        vanityUrl: z5.string().optional().describe("\u73A9\u5BB6\u7684 Steam \u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\uFF0C\u4F8B\u5982 'gaben'\u3002\u4E0E steamid \u4E8C\u9009\u4E00\uFF1B\u82E5\u90FD\u4E0D\u4F20\u4E14\u5DF2\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528\u8BE5\u503C\u3002"),
-        key: z5.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        includeAppInfo: z5.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6E38\u620F\u540D\u79F0\u548C\u56FE\u6807\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includePlayedFreeGames: z5.boolean().optional().describe("\u662F\u5426\u5305\u542B\u73A9\u8FC7\u7684\u514D\u8D39\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        includeRecentGames: z5.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\u7684\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
-        recentGamesCount: z5.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 5\u3002"),
-        topGamesCount: z5.number().int().min(1).max(50).optional().describe("\u6309\u6E38\u73A9\u65F6\u957F\u6392\u5E8F\u8FD4\u56DE\u524D\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 10\u3002")
+        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"),
+        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
+        includeAppInfo: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6E38\u620F\u540D\u79F0\u548C\u56FE\u6807\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includePlayedFreeGames: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u73A9\u8FC7\u7684\u514D\u8D39\u6E38\u620F\uFF0C\u9ED8\u8BA4 true\u3002"),
+        includeRecentGames: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u6700\u8FD1\u6E38\u73A9\uFF0C\u9ED8\u8BA4 true\u3002"),
+        recentGamesCount: z4.number().int().min(1).max(20).optional().describe("\u6700\u8FD1\u6E38\u73A9\u6E38\u620F\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 5\u3002"),
+        topGamesCount: z4.number().int().min(1).max(50).optional().describe("\u6309\u65F6\u957F\u6392\u5E8F\u8FD4\u56DE\u524D\u591A\u5C11\u4E2A\u6E38\u620F\uFF0C\u9ED8\u8BA4 10\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13734,38 +13752,34 @@ function registerOverviewTools(server, runtime2) {
       includeRecentGames = true,
       recentGamesCount = 5,
       topGamesCount = 10
-    }) => {
-      try {
-        const payload = await buildLibraryOverviewData(runtime2, {
-          toolName: "steam_get_library_overview",
-          steamid,
-          vanityUrl,
-          key,
-          includeAppInfo,
-          includePlayedFreeGames,
-          includeRecentGames,
-          recentGamesCount,
-          topGamesCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_get_library_overview", error);
-      }
-    }
+    }) => buildLibraryOverviewData(runtime2, {
+      toolName: "steam_get_library_overview",
+      steamid,
+      vanityUrl,
+      key,
+      includeAppInfo,
+      includePlayedFreeGames,
+      includeRecentGames,
+      recentGamesCount,
+      topGamesCount
+    })
   );
-  server.registerTool(
-    "steam_get_achievement_overview",
+  registerSteamTool(
+    server,
+    runtime2,
+    "steam_get_player_game_achievements",
     {
-      title: "Steam \u6210\u5C31\u603B\u89C8",
-      description: "\u805A\u5408\u67D0\u4E2A\u6E38\u620F\u7684\u73A9\u5BB6\u6210\u5C31\u3001\u6E38\u620F schema\u3001\u5168\u5C40\u5B8C\u6210\u7387\u548C\u53EF\u9009\u7684\u4E2A\u4EBA\u7EDF\u8BA1\u3002",
+      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",
       inputSchema: {
-        steamid: z5.union([z5.string(), z5.number()]).optional().describe("\u73A9\u5BB6\u7684 SteamID64\u3002\u4E0E vanityUrl \u4E8C\u9009\u4E00\uFF1B\u82E5\u90FD\u4E0D\u4F20\u4E14\u5DF2\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528\u8BE5\u503C\u3002"),
-        vanityUrl: z5.string().optional().describe("\u73A9\u5BB6\u7684 Steam \u81EA\u5B9A\u4E49\u4E3B\u9875\u6807\u8BC6\uFF0C\u4F8B\u5982 'gaben'\u3002\u4E0E steamid \u4E8C\u9009\u4E00\uFF1B\u82E5\u90FD\u4E0D\u4F20\u4E14\u5DF2\u914D\u7F6E STEAM_DEFAULT_STEAMID\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528\u8BE5\u503C\u3002"),
-        appid: z5.union([z5.string(), z5.number()]).describe("\u8981\u67E5\u770B\u7684 Steam AppID\u3002"),
-        key: z5.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
-        language: z5.string().optional().describe("\u53EF\u9009\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 'schinese' \u6216 'english'\u3002"),
-        includeStats: z5.boolean().optional().describe("\u662F\u5426\u5305\u542B\u8BE5\u6E38\u620F\u7684\u73A9\u5BB6\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
-        recentUnlockedCount: z5.number().int().min(1).max(50).optional().describe("\u9AD8\u4EAE\u5C55\u793A\u6700\u8FD1\u89E3\u9501\u6210\u5C31\u7684\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002")
+        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"),
+        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"),
+        key: z4.string().optional().describe("\u53EF\u9009\u7684 Steam Web API key \u8986\u76D6\u503C\u3002"),
+        language: z4.string().optional().describe("\u8BED\u8A00\u4EE3\u7801\uFF0C\u4F8B\u5982 schinese \u6216 english\u3002"),
+        includeStats: z4.boolean().optional().describe("\u662F\u5426\u5305\u542B\u73A9\u5BB6\u7EDF\u8BA1\uFF0C\u9ED8\u8BA4 true\u3002"),
+        recentUnlockedCount: z4.number().int().min(1).max(50).optional().describe("\u6700\u8FD1\u89E3\u9501\u6210\u5C31\u7684\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13776,40 +13790,38 @@ function registerOverviewTools(server, runtime2) {
       steamid,
       vanityUrl,
       appid,
+      query,
       key,
       language,
       includeStats = true,
       recentUnlockedCount = 10
-    }) => {
-      try {
-        const payload = await buildAchievementOverviewData(runtime2, {
-          toolName: "steam_get_achievement_overview",
-          steamid,
-          vanityUrl,
-          appid,
-          key,
-          language,
-          includeStats,
-          recentUnlockedCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_get_achievement_overview", error);
-      }
-    }
+    }) => buildPlayerGameAchievementsData(runtime2, {
+      toolName: "steam_get_player_game_achievements",
+      steamid,
+      vanityUrl,
+      appid,
+      query,
+      key,
+      language,
+      includeStats,
+      recentUnlockedCount
+    })
   );
-  server.registerTool(
-    "steam_get_news_overview",
+  registerSteamTool(
+    server,
+    runtime2,
+    "steam_get_app_news",
     {
-      title: "Steam \u65B0\u95FB\u603B\u89C8",
-      description: "\u805A\u5408\u67D0\u4E2A\u5E94\u7528\u7684 Steam \u65B0\u95FB\uFF0C\u5E76\u53EF\u9009\u9644\u5E26\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\u3002",
+      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",
       inputSchema: {
-        appid: z5.union([z5.string(), z5.number()]).describe("\u8981\u67E5\u770B\u7684 Steam AppID\u3002"),
-        count: z5.number().int().min(1).max(20).optional().describe("\u8FD4\u56DE\u591A\u5C11\u6761\u65B0\u95FB\uFF0C\u9ED8\u8BA4 5\u3002"),
-        maxlength: z5.number().int().min(0).max(5e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u5185\u5BB9\u7684\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 300\u3002"),
-        enddate: z5.number().int().optional().describe("\u53EF\u9009\u7684 Unix \u65F6\u95F4\u6233\u4E0A\u9650\uFF0C\u53EA\u8FD4\u56DE\u66F4\u65E9\u7684\u65B0\u95FB\u3002"),
-        feeds: z5.union([z5.string(), z5.array(z5.string())]).optional().describe("\u53EF\u9009\u7684 feed \u540D\u79F0\u6216 feed \u5217\u8868\u3002"),
-        includePlayerCount: z5.boolean().optional().describe("\u662F\u5426\u5305\u542B\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002")
+        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"),
+        count: z4.number().int().min(1).max(20).optional().describe("\u8FD4\u56DE\u65B0\u95FB\u6761\u6570\uFF0C\u9ED8\u8BA4 5\u3002"),
+        maxlength: z4.number().int().min(0).max(5e3).optional().describe("\u6BCF\u6761\u65B0\u95FB\u5185\u5BB9\u6700\u5927\u957F\u5EA6\uFF0C\u9ED8\u8BA4 300\u3002"),
+        enddate: z4.number().int().optional().describe("\u53EF\u9009\u7684 Unix \u65F6\u95F4\u6233\u4E0A\u9650\u3002"),
+        feeds: z4.union([z4.string(), z4.array(z4.string())]).optional().describe("\u53EF\u9009\u7684 feed \u540D\u79F0\u6216\u5217\u8868\u3002"),
+        includePlayerCount: z4.boolean().optional().describe("\u662F\u5426\u9644\u5E26\u5F53\u524D\u5728\u7EBF\u4EBA\u6570\uFF0C\u9ED8\u8BA4 true\u3002")
       },
       annotations: {
         readOnlyHint: true,
@@ -13818,34 +13830,27 @@ function registerOverviewTools(server, runtime2) {
     },
     async ({
       appid,
+      query,
       count = 5,
       maxlength = 300,
       enddate,
       feeds,
       includePlayerCount = true
-    }) => {
-      try {
-        const payload = await buildNewsOverviewData(runtime2, {
-          toolName: "steam_get_news_overview",
-          appid,
-          count,
-          maxlength,
-          enddate,
-          feeds,
-          includePlayerCount
-        });
-        return runtime2.createJsonToolResult(payload);
-      } catch (error) {
-        return runtime2.createErrorToolResult("steam_get_news_overview", error);
-      }
-    }
+    }) => buildAppNewsData(runtime2, {
+      toolName: "steam_get_app_news",
+      appid,
+      query,
+      count,
+      maxlength,
+      enddate,
+      feeds,
+      includePlayerCount
+    })
   );
 }
 
 // src/server.ts
 var spec = applyGeneratedToolTitles(steam_web_api_spec_default);
-var generatedToolsEnabled = toBoolean(process.env.STEAM_ENABLE_GENERATED_TOOLS) ?? false;
-var helperToolCount = 4;
 var runtime = createSteamBaseRuntime(spec, {
   apiKey: process.env.STEAM_WEB_API_KEY,
   defaultSteamId: normalizeScalarInput(process.env.STEAM_DEFAULT_STEAMID),
@@ -13855,34 +13860,22 @@ var runtime = createSteamBaseRuntime(spec, {
   ),
   timeoutMs: Number.parseInt(process.env.STEAM_REQUEST_TIMEOUT_MS ?? "30000", 10)
 });
-function createAdvancedToolsStatus() {
-  if (!generatedToolsEnabled) {
-    return "advanced tools: disabled";
-  }
-  return `advanced tools: enabled (${helperToolCount} helper + ${runtime.spec.methodCount} generated)`;
-}
 function createServer() {
   const server = new McpServer({
     name: "steam-tools-mcp",
-    version: "0.1.0",
+    version: "0.2.0",
     websiteUrl: "https://partner.steamgames.com/doc/webapi"
   });
   registerOverviewTools(server, runtime);
   registerAppTools(server, runtime);
   registerMyAccountTools(server, runtime);
-  if (generatedToolsEnabled) {
-    registerHelperTools(server, runtime);
-    registerGeneratedTools(server, runtime);
-  }
   return server;
 }
 async function startStdioServer() {
   const server = createServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(
-    `steam-tools-mcp running over stdio. ${createAdvancedToolsStatus()}.`
-  );
+  console.error("steam-tools-mcp running over stdio.");
 }
 async function handleHttpRequest(req, res) {
   const server = createServer();
@@ -13920,9 +13913,7 @@ async function startHttpServer() {
       ok: true,
       generatedAt: runtime.spec.generatedAt,
       methodCount: runtime.spec.methodCount,
-      interfaceCount: runtime.spec.interfaceCount,
-      generatedToolsEnabled,
-      enabledGeneratedToolCount: generatedToolsEnabled ? runtime.spec.methodCount : 0
+      interfaceCount: runtime.spec.interfaceCount
     });
   });
   app.post("/mcp", async (req, res) => {
@@ -13954,9 +13945,7 @@ async function startHttpServer() {
         reject(error);
         return;
       }
-      console.log(
-        `steam-tools-mcp listening on http://${host}:${port}/mcp. ${createAdvancedToolsStatus()}.`
-      );
+      console.log(`steam-tools-mcp listening on http://${host}:${port}/mcp.`);
       resolve();
     });
     server.on("error", reject);