@@ -10,6 +10,7 @@ import {
   type GenerateOptions,
   type LlmCallConfig,
   type LlmFailure,
+  type LlmResolvedModelInfo,
   type PreparedLlmCall,
   type StreamChunk,
 } from "@deepseek-ai/dsh-llm";
@@ -29,6 +30,7 @@ const HOST_LLM_TIMEOUT_CODE = "MEMOS_DSH_HOST_LLM_TIMEOUT";
 const HOST_LLM_MESSAGE_SOURCE = "memos-local-memory";
 const NO_REASONING_EFFORT = ReasoningEffortId("off");
 const UNSUPPORTED_REASONING_EFFORT = "UNSUPPORTED_REASONING_EFFORT";
+const MODEL_CAPABILITY_TTL_MS = 10 * 60 * 1_000;
 
 /** Atomic provider/model route captured from the DSH agent that owns a turn. */
 export interface DeepSeekHarnessLlmRoute {
@@ -40,12 +42,34 @@ export interface DeepSeekHarnessLlmRoute {
 
 /** Public subset of DSH's LLM runtime used by this adapter. */
 export interface DeepSeekHarnessLlmLike {
+  resolveModelInfo(
+    provider: string,
+    model: string,
+    signal?: AbortSignal,
+  ): Promise<LlmResolvedModelInfo>;
   prepareCall(
     config: LlmCallConfig,
     signal?: AbortSignal,
   ): Promise<PreparedLlmCall>;
 }
 
+export interface DeepSeekHarnessHostLlmBridge extends HostLlmBridge {
+  /** Drop exact-route capability snapshots after a DSH adapter topology update. */
+  invalidateModelCapabilities(): void;
+}
+
+type AuxiliaryReasoningCapability = "off" | "plain";
+
+interface CapabilityCacheEntry {
+  readonly expiresAt: number;
+  readonly value: Promise<AuxiliaryReasoningCapability>;
+}
+
+interface CapabilityCache {
+  readonly entries: Map<string, CapabilityCacheEntry>;
+  generation: number;
+}
+
 /**
  * Async route scope for MemOS work spawned by one DSH session.
  *
@@ -95,9 +119,17 @@ export interface CreateDeepSeekHarnessHostLlmBridgeOptions {
  */
 export function createDeepSeekHarnessHostLlmBridge(
   options: CreateDeepSeekHarnessHostLlmBridgeOptions,
-): HostLlmBridge {
+): DeepSeekHarnessHostLlmBridge {
+  const capabilityCache: CapabilityCache = {
+    entries: new Map(),
+    generation: 0,
+  };
   return {
     id: HOST_LLM_BRIDGE_ID,
+    invalidateModelCapabilities(): void {
+      capabilityCache.generation++;
+      capabilityCache.entries.clear();
+    },
     async complete(input: HostLlmCompleteInput): Promise<HostLlmCompletion> {
       const route = options.routes.current();
       if (!route) {
@@ -122,6 +154,7 @@ export function createDeepSeekHarnessHostLlmBridge(
           input,
           route,
           callDeadline.signal,
+          capabilityCache,
         );
         const request = createGenerateOptions(input, route, prepared.config);
         request.signal = callDeadline.signal;
@@ -217,20 +250,30 @@ function createGenerateOptions(
  *
  * Retrieval filters and JSON extractors intentionally use small output caps.
  * Reusing a conversation's high reasoning effort can spend that entire cap on
- * reasoning and produce no JSON/text. DSH effort ids are adapter-owned, so the
- * exact registered adapter validates the branded conventional `off` id. Only
- * an explicit unsupported-effort result retries without it, preserving the
- * adapter/provider default. prepareCall performs no provider generation I/O
- * and binds that validation to the same registration used for dispatch, even
- * if HMR replaces the route before the returned stream starts.
+ * reasoning and produce no JSON/text. Resolve exact-model metadata through
+ * DSH, then cache whether its adapter advertises the conventional `off` id.
+ * prepareCall remains the final registration-bound authority: if HMR changes
+ * the route after metadata resolution, an explicit unsupported-effort result
+ * refreshes the cache and retries with the adapter/provider default.
  */
 async function prepareAuxiliaryCall(
   llm: DeepSeekHarnessLlmLike,
   input: HostLlmCompleteInput,
   route: DeepSeekHarnessLlmRoute,
   signal: AbortSignal,
+  capabilityCache: CapabilityCache,
 ): Promise<PreparedLlmCall> {
   const config = createCallConfig(input, route);
+  const capability = await resolveAuxiliaryReasoningCapability(
+    llm,
+    route,
+    signal,
+    capabilityCache,
+  );
+  if (capability === "plain") {
+    return llm.prepareCall(config, signal);
+  }
+  const preparationGeneration = capabilityCache.generation;
   try {
     return await llm.prepareCall(
       { ...config, reasoningEffort: NO_REASONING_EFFORT },
@@ -243,10 +286,64 @@ async function prepareAuxiliaryCall(
     ) {
       throw error;
     }
+    // The exact adapter may have changed after the metadata lookup. Preserve
+    // prepareCall's registration-bound validation as the final authority and
+    // remember the corrected capability only if no newer topology update has
+    // already invalidated this preparation generation.
+    if (capabilityCache.generation === preparationGeneration) {
+      rememberAuxiliaryReasoningCapability(route, "plain", capabilityCache);
+    }
     return llm.prepareCall(config, signal);
   }
 }
 
+function capabilityRouteKey(route: DeepSeekHarnessLlmRoute): string {
+  return JSON.stringify([route.provider, route.model]);
+}
+
+function rememberAuxiliaryReasoningCapability(
+  route: DeepSeekHarnessLlmRoute,
+  capability: AuxiliaryReasoningCapability,
+  cache: CapabilityCache,
+): void {
+  cache.entries.set(capabilityRouteKey(route), {
+    expiresAt: Date.now() + MODEL_CAPABILITY_TTL_MS,
+    value: Promise.resolve(capability),
+  });
+}
+
+async function resolveAuxiliaryReasoningCapability(
+  llm: DeepSeekHarnessLlmLike,
+  route: DeepSeekHarnessLlmRoute,
+  signal: AbortSignal,
+  cache: CapabilityCache,
+): Promise<AuxiliaryReasoningCapability> {
+  const key = capabilityRouteKey(route);
+  const cached = cache.entries.get(key);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.value;
+  }
+  if (cached) cache.entries.delete(key);
+
+  let entry: CapabilityCacheEntry;
+  const value = llm.resolveModelInfo(route.provider, route.model, signal)
+    .then((info): AuxiliaryReasoningCapability => (
+      info.reasoning?.efforts.some((effort) => effort.id === NO_REASONING_EFFORT)
+        ? "off"
+        : "plain"
+    ))
+    .catch((error: unknown) => {
+      if (cache.entries.get(key) === entry) cache.entries.delete(key);
+      throw error;
+    });
+  entry = {
+    expiresAt: Date.now() + MODEL_CAPABILITY_TTL_MS,
+    value,
+  };
+  cache.entries.set(key, entry);
+  return value;
+}
+
 function createCallConfig(
   input: HostLlmCompleteInput,
   route: DeepSeekHarnessLlmRoute,
 
@@ -36,6 +36,7 @@ import {
 import {
   createDeepSeekHarnessHostLlmBridge,
   DeepSeekHarnessLlmRouteContext,
+  type DeepSeekHarnessHostLlmBridge,
 } from "./host-llm.js";
 import { registerDeepSeekHarnessTools } from "./tools.js";
 
@@ -126,6 +127,16 @@ export function configureDeepSeekHarnessHostLlm(
   });
 }
 
+/** Refresh exact-model capability snapshots whenever DSH replaces an adapter. */
+export function registerDeepSeekHarnessHostLlmCapabilityInvalidation(
+  ctx: Context,
+  bridge: DeepSeekHarnessHostLlmBridge,
+): () => void {
+  return ctx.on("llm/adapters-updated", () => {
+    bridge.invalidateModelCapabilities();
+  });
+}
+
 /** Autonomous recovery has no owning DSH turn from which to capture a route. */
 export function deepSeekHarnessAutoRecoveryEnabled(config: ResolvedConfig): boolean {
   return config.llm.provider.trim().toLowerCase() !== "host" ||
@@ -247,6 +258,12 @@ export async function apply(
     const hostLlmBridge = config.hostLlmEnabled
       ? createDeepSeekHarnessHostLlmBridge({ llm: ctx.llm, routes })
       : null;
+    if (hostLlmBridge) {
+      registrations.push(registerDeepSeekHarnessHostLlmCapabilityInvalidation(
+        ctx,
+        hostLlmBridge,
+      ));
+    }
     const autoRecoveryEnabled = deepSeekHarnessAutoRecoveryEnabled(memoryConfig);
 
     core = await bootstrapMemoryCore({
 
@@ -1504,12 +1504,12 @@ def get_tool_schemas(self) -> list[dict[str, Any]]:  # type: ignore[override]
 
     def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any) -> str:  # type: ignore[override]
         if not self._bridge:
-            return json.dumps({"error": "bridge not connected"})
+            return json.dumps({"error": "bridge not connected"}, ensure_ascii=False)
         try:
             if tool_name == "memos_search":
                 query = (args.get("query") or "").strip()
                 if not query:
-                    return json.dumps({"error": "missing query"})
+                    return json.dumps({"error": "missing query"}, ensure_ascii=False)
                 max_results = self._int_arg(args, "maxResults", 10, 1, 50)
                 params: dict[str, Any] = {
                     "agent": "hermes",
@@ -1528,11 +1528,11 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                     params,
                     timeout=_LONG_RPC_TIMEOUT,
                 )
-                return json.dumps({"hits": resp.get("hits", [])})
+                return json.dumps({"hits": resp.get("hits", [])}, ensure_ascii=False)
             if tool_name == "memos_get":
                 item_id = (args.get("id") or "").strip()
                 if not item_id:
-                    return json.dumps({"error": "missing id"})
+                    return json.dumps({"error": "missing id"}, ensure_ascii=False)
                 kind = args.get("kind") or "trace"
                 methods = {
                     "trace": "memory.get_trace",
@@ -1541,12 +1541,14 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                 }
                 method = methods.get(kind)
                 if method is None:
-                    return json.dumps({"error": f"unknown memory kind: {kind}"})
+                    return json.dumps({"error": f"unknown memory kind: {kind}"}, ensure_ascii=False)
                 item = self._bridge_request_with_retry(
                     method, {"id": item_id, "namespace": self._runtime_namespace()}
                 )
                 if not item:
-                    return json.dumps({"found": False, "kind": kind, "id": item_id})
+                    return json.dumps(
+                        {"found": False, "kind": kind, "id": item_id}, ensure_ascii=False
+                    )
                 if kind == "trace":
                     body = self._clip(item.get("agentText") or item.get("body"))
                     meta = {
@@ -1584,7 +1586,8 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                         "id": item.get("id", item_id),
                         "body": body,
                         "meta": meta,
-                    }
+                    },
+                    ensure_ascii=False,
                 )
             if tool_name == "memos_timeline":
                 resp = self._bridge_request_with_retry(
@@ -1596,13 +1599,16 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                 )
                 limit = self._int_arg(args, "limit", 20, 1, 100)
                 traces = resp.get("traces", [])[:limit]
-                return json.dumps({"traces": traces})
+                return json.dumps({"traces": traces}, ensure_ascii=False)
             if tool_name == "memos_skill_list":
                 limit = self._int_arg(args, "limit", 10, 1, 50)
                 params = {"limit": limit, "namespace": self._runtime_namespace()}
                 if args.get("status"):
                     params["status"] = args["status"]
-                return json.dumps(self._bridge_request_with_retry("skill.list", params))
+                return json.dumps(
+                    self._bridge_request_with_retry("skill.list", params),
+                    ensure_ascii=False,
+                )
             if tool_name == "memos_environment":
                 query = (args.get("query") or "").strip()
                 limit = self._int_arg(args, "limit", 5, 1, 30)
@@ -1621,7 +1627,8 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                                 for w in resp.get("worldModels", [])
                             ],
                             "queried": False,
-                        }
+                        },
+                        ensure_ascii=False,
                     )
                 resp = self._bridge_request_with_retry(
                     "memory.search",
@@ -1651,12 +1658,13 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                             for h in hits[:limit]
                         ],
                         "queried": True,
-                    }
+                    },
+                    ensure_ascii=False,
                 )
             if tool_name == "memos_skill_get":
                 skill_id = (args.get("id") or "").strip()
                 if not skill_id:
-                    return json.dumps({"error": "missing id"})
+                    return json.dumps({"error": "missing id"}, ensure_ascii=False)
                 skill = self._bridge_request_with_retry(
                     "skill.get",
                     {
@@ -1667,10 +1675,10 @@ def handle_tool_call(self, tool_name: str, args: dict[str, Any], **_kwargs: Any)
                         "episodeId": self._episode_id or None,
                     },
                 )
-                return json.dumps({"found": bool(skill), "skill": skill})
+                return json.dumps({"found": bool(skill), "skill": skill}, ensure_ascii=False)
         except Exception as err:
-            return json.dumps({"error": str(err)})
-        return json.dumps({"error": f"unknown tool: {tool_name}"})
+            return json.dumps({"error": str(err)}, ensure_ascii=False)
+        return json.dumps({"error": f"unknown tool: {tool_name}"}, ensure_ascii=False)
 
     # ─── Config schema (for `hermes memory setup`) ────────────────────────