refactor(tools): model_dump() instead of the deprecated Pydantic dict()

mcp_server/tools/episodic.py

@@ -40,7 +40,7 @@ async def memory_episode_save(
     await _fire_hook("state_delta", layer, {"summary": summary, "tags": tags, "user_id": user_id})
     await _fire_hook("consolidation", layer, {"trigger": "episode_save", "user_id": user_id})
 
-    return EpisodeResult(episode_id=episode_id).dict()
+    return EpisodeResult(episode_id=episode_id).model_dump()
 
 
 async def memory_episode_recall(
@@ -64,7 +64,7 @@ async def memory_episode_recall(
         episodes = await mem.l3.search_by_tag(user_id, tag, limit)
     else:
         episodes = await mem.l3.get_episodes(user_id, limit)
-    return EpisodeResult(episodes=[{"id": e.episode_id, "summary": e.summary, "weight": e.emotional_weight} for e in episodes]).dict()
+    return EpisodeResult(episodes=[{"id": e.episode_id, "summary": e.summary, "weight": e.emotional_weight} for e in episodes]).model_dump()
 
 
 async def memory_episode_list(

mcp_server/tools/graph.py

@@ -97,7 +97,7 @@ async def memory_graph_add(
     if hook_name:
         await _fire_hook(hook_name, layer, {"node_type": node_type, "content": content, "user_id": user_id})
 
-    return GraphNodeResult(node_id=node_id, created=created).dict()
+    return GraphNodeResult(node_id=node_id, created=created).model_dump()
 
 
 async def memory_graph_query(
@@ -124,7 +124,7 @@ async def memory_graph_query(
         nodes = await graph.query_by_type(user_id, node_type, limit)
     else:
         nodes = []
-    return GraphNodeResult(nodes=[{"id": n.node_id, "content": n.content, "type": n.node_type, "tags": n.tags} for n in nodes]).dict()
+    return GraphNodeResult(nodes=[{"id": n.node_id, "content": n.content, "type": n.node_type, "tags": n.tags} for n in nodes]).model_dump()
 
 
 async def memory_graph_nodes(

mcp_server/tools/memory.py

@@ -46,7 +46,7 @@ async def memory_remember(
     value = strip_secrets(value)
     if session_id and _dedup_cache.is_duplicate(session_id, key, value):
         logger.info("Dedup: skipping identical remember key=%s user=%s", key, user_id)
-        return RememberResult(status="skipped", reason="duplicate_within_ttl").dict()
+        return RememberResult(status="skipped", reason="duplicate_within_ttl").model_dump()
 
     app = _get_ctx(ctx)
     layer = _validate_layer(layer)
@@ -60,7 +60,7 @@ async def memory_remember(
     gate = await _fire_hook("importance_gate", layer, {"text": value, "key": key, "importance": importance})
     if gate.get("results") and any(r.get("bypass") for r in gate["results"] if isinstance(r, dict)):
         logger.info("Importance gate bypassed: key=%s, importance=%.2f, user=%s", key, importance, user_id)
-        return RememberResult(status="skipped", reason="below_importance_threshold").dict()
+        return RememberResult(status="skipped", reason="below_importance_threshold").model_dump()
 
     mem = _get_memory(app, layer, user_id)
 
@@ -92,7 +92,7 @@ async def memory_remember(
         await _fire_hook("message_received", layer, {"text": value, "key": key, "user_id": user_id}, mem=mem)
 
     _invalidate_cache(layer, user_id)
-    return RememberResult(status="ok", entry_id=entry_id, graph_node_id=None).dict()
+    return RememberResult(status="ok", entry_id=entry_id, graph_node_id=None).model_dump()
 
 
 async def _fire_post_remember_hooks(layer: str, user_id: str, key: str, value: str, mem: Any, graph: Any = None) -> None:
@@ -125,14 +125,14 @@ async def memory_recall(
 
     cached = _get_recall_cache(query, user_id, layer, limit)
     if cached is not None:
-        return {**RecallResult(results=cached, count=len(cached)).dict(), "cached": True}
+        return {**RecallResult(results=cached, count=len(cached)).model_dump(), "cached": True}
 
     results = await _get_memory(app, layer, user_id).recall(query, limit)
     _set_recall_cache(query, user_id, layer, limit, results)
 
     await _fire_hook("auto_context", layer, {"query": query, "results_count": len(results), "user_id": user_id})
 
-    return RecallResult(results=results, count=len(results)).dict()
+    return RecallResult(results=results, count=len(results)).model_dump()
 
 
 # memory_forget was removed: a strict subset of the `forget` primitive

mcp_server/tools/ops.py

@@ -79,7 +79,7 @@ async def memory_stats(
         graph_edges_cross_layer=graph_edges["cross_layer"],
         avg_session_quality=await mem.l2.avg_quality(user_id),
         recall_count=await count_recalls(app.mm._cm, user_id),
-    ).dict()
+    ).model_dump()
 
 
 async def memory_context(
@@ -138,7 +138,7 @@ async def memory_context(
         l3_episodes_count=len(l3_episodes),
         l1_recent_count=len(l1_recent),
         wiki_count=len(wiki_entries),
-    ).dict()
+    ).model_dump()
     _set_cached(cache_key, result)
     return result
 
@@ -320,13 +320,13 @@ async def memory_api_key(
     try:
         if action == "create":
             key = api_key_auth.create_key(user_id, label)
-            return ApiKeyResult(api_key=key, user_id=user_id, label=label).dict()
+            return ApiKeyResult(api_key=key, user_id=user_id, label=label).model_dump()
         if action == "revoke":
             revoked = api_key_auth.revoke(api_key)
-            return ApiKeyResult(revoked=revoked).dict()
-        return ApiKeyResult(keys=api_key_auth.list_keys()).dict()
+            return ApiKeyResult(revoked=revoked).model_dump()
+        return ApiKeyResult(keys=api_key_auth.list_keys()).model_dump()
     except StoreUnreadable:
-        return ApiKeyResult(error=ERROR_KEY_STORE_UNREADABLE).dict()
+        return ApiKeyResult(error=ERROR_KEY_STORE_UNREADABLE).model_dump()
 
 
 async def memory_backup(
@@ -341,12 +341,12 @@ async def memory_backup(
     metrics.inc("tool_backup")
 
     if action == "now":
-        return BackupNowResult(path=backup_cron.backup_now()).dict()
+        return BackupNowResult(path=backup_cron.backup_now()).model_dump()
     if action == "list":
-        return BackupListResult(backups=backup_cron.list_backups()).dict()
+        return BackupListResult(backups=backup_cron.list_backups()).model_dump()
     if action == "restore":
-        return BackupRestoreResult(**backup_cron.restore(backup_name)).dict()
-    return BackupStatusResult(**backup_cron.status()).dict()
+        return BackupRestoreResult(**backup_cron.restore(backup_name)).model_dump()
+    return BackupStatusResult(**backup_cron.status()).model_dump()
 
 
 async def memory_saga(
@@ -389,13 +389,13 @@ async def memory_data(
 
     if action == "export":
         path = await app.import_export.export_user(user_id, mm=app.mm)
-        return DataResult(path=path).dict()
+        return DataResult(path=path).model_dump()
     if action == "import":
         result = await app.import_export.import_user(file_path, target_user_id or user_id, mm=app.mm)
         for layer in ("user", "agent"):
             _invalidate_cache(layer, target_user_id or user_id)
-        return DataResult(**result).dict()
-    return DataResult(exports=app.import_export.list_exports()).dict()
+        return DataResult(**result).model_dump()
+    return DataResult(exports=app.import_export.list_exports()).model_dump()
 
 
 async def memory_sync_replica(
@@ -449,7 +449,7 @@ async def memory_cleanup(
         backup_cleanup=results[4],
         saga_cleanup=saga_watchdog.cleanup_completed(),
         compaction=results[5].get("archived", 0) if isinstance(results[5], dict) else 0,
-    ).dict()
+    ).model_dump()
 
 
 async def memory_lucidity_purge(
@@ -480,7 +480,7 @@ async def memory_lucidity_purge(
         audit=results[2],
         graph_nodes=results[3],
         staging=results[4],
-    ).dict()
+    ).model_dump()
 
 
 # Whitelisted purge targets — never accept caller-supplied identifiers.
@@ -561,7 +561,7 @@ async def memory_search(
             include_rag=include_rag,
             include_wiki=include_wiki,
         )
-    return SearchResult(results=results, count=len(results), method=strategy).dict()
+    return SearchResult(results=results, count=len(results), method=strategy).model_dump()
 
 
 # ── CONTEXT.md persistence (research backlog 3.13) ──────────────

mcp_server/tools/primitives/dream.py

@@ -99,4 +99,4 @@ async def dream(
         summary=summary,
         truncated=truncated,
         result_count=len(results),
-    ).dict()
+    ).model_dump()

mcp_server/tools/primitives/evolve.py

@@ -50,4 +50,4 @@ async def evolve(
     hook_result = await _fire_hook("personality_shift", "agent", {"instruction": instruction, "user_id": user_id}, mem=mem)
 
     summary = hook_result.get("summary", "Personality evolution recorded.")
-    return EvolveResult(status="ok", summary=summary).dict()
+    return EvolveResult(status="ok", summary=summary).model_dump()

mcp_server/tools/primitives/forget.py

@@ -159,7 +159,7 @@ async def forget(
             restored_items=outcome.restored_items,
             refused=outcome.refused,
             not_found=outcome.not_found,
-        ).dict()
+        ).model_dump()
 
     mem = _get_memory(app, layer, user_id)
     graph = _get_graph(app, layer)
@@ -185,7 +185,7 @@ async def forget(
         episodes=outcome.episodes,
         graph_nodes=outcome.graph_nodes,
         not_found=outcome.not_found,
-    ).dict()
+    ).model_dump()
 
 
 async def _forget_exact(app: AppContext, key: str, user_id: str, mem: Any, shadow_bin: bool, dry_run: bool = False) -> _Outcome:

mcp_server/tools/primitives/project.py

@@ -88,7 +88,7 @@ async def project(
     }
     handler = handlers.get(action)
     if handler is None:
-        return ProjectResult(status="error", title=name, audit_report=f"unknown action: {action}").dict()
+        return ProjectResult(status="error", title=name, audit_report=f"unknown action: {action}").model_dump()
 
     status_res, result_extra, audit_report, wiki_path = await handler(
         pctx,
@@ -101,7 +101,7 @@ async def project(
         decision=decision,
         outcome=outcome,
     )
-    return {**ProjectResult(status=status_res, title=name, path=wiki_path, audit_report=audit_report).dict(), **result_extra}
+    return {**ProjectResult(status=status_res, title=name, path=wiki_path, audit_report=audit_report).model_dump(), **result_extra}
 
 
 async def _action_init(pctx: _ProjectCtx, *, name: str, details: str, path: str, **_: Any) -> tuple[str, dict[str, Any], None, str | None]:

mcp_server/tools/primitives/think.py

@@ -208,4 +208,4 @@ async def _capture_think() -> None:
     if awaitable_tasks:
         await asyncio.gather(*awaitable_tasks)
 
-    return ThinkResult(status="ok", routing=routing, actions=actions).dict()
+    return ThinkResult(status="ok", routing=routing, actions=actions).model_dump()

mcp_server/tools/session.py

@@ -30,7 +30,7 @@ async def memory_session_start(
     session_id = await _get_memory(app, layer, user_id).l2.create_session(user_id)
     await _fire_hook("message_received", layer, {"text": "session_started", "session_id": session_id, "user_id": user_id})
 
-    return SessionResult(session_id=session_id).dict()
+    return SessionResult(session_id=session_id).model_dump()
 
 
 async def memory_session_end(
@@ -60,7 +60,7 @@ async def memory_session_end(
     await _fire_hook("consolidation", layer, {"trigger": "session_end", "session_id": session_id, "user_id": user_id})
     await _fire_hook("state_delta", layer, {"trigger": "session_end", "session_id": session_id, "summary": summary, "user_id": user_id})
 
-    return SessionResult(status="ok").dict()
+    return SessionResult(status="ok").model_dump()
 
 
 async def memory_session_list(