refactor(block-h): own integration agent tools in their plugins

app/plugins/builtins/knowledge/plugin.py

@@ -1,6 +1,8 @@
 """Knowledge plugin — LLM-based entity/relationship extraction, ask-knowledge, review queue."""
 from __future__ import annotations
 import logging
+import uuid
+from typing import Any
 from app.plugins.base import BasePlugin
 from app.plugins.manifest import PluginManifest, PluginRouteDef
 
@@ -59,9 +61,97 @@ class KnowledgePlugin(BasePlugin):
             logger.info("Registered knowledge extraction hooks")
         except Exception:
             logger.exception("Failed to register knowledge hooks")
+        # Register knowledge agent tools (I-AK: Agent→Knowledge)
+        try:
+            self._register_knowledge_agent_tools()
+        except Exception:
+            logger.exception("Failed to register knowledge agent tools")
+
+    def _register_knowledge_agent_tools(self) -> None:
+        """Register I-AK agent tools for asking and searching knowledge."""
+        from app.ai.tool_registry import get_tool_registry
+        registry = get_tool_registry()
+
+        async def _ask_knowledge_handler(arguments: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:
+            """Ask a knowledge question."""
+            from app.plugins.builtins.knowledge.services import ask_knowledge
+            from app.core.db import get_worker_session_factory
+            question = arguments.get("question", "")
+            tenant_id = context.get("tenant_id")
+            if not question or not tenant_id:
+                return {"error": "question and tenant_id required"}
+            factory = get_worker_session_factory()
+            async with factory() as db:
+                result = await ask_knowledge(db=db, tenant_id=uuid.UUID(str(tenant_id)), question=question)
+                return {"answer": result.get("answer", ""), "evidence_count": len(result.get("evidence", []))}
+
+        registry.register(
+            name="ask_knowledge",
+            description="Ask a knowledge question. Searches wiki articles and graph relationships for context.",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "question": {"type": "string", "description": "The question to ask"},
+                },
+                "required": ["question"],
+            },
+            handler=_ask_knowledge_handler,
+            plugin_name=self.manifest.name,
+            required_permission="wiki:read",
+            category="knowledge",
+        )
+
+        async def _search_knowledge_handler(arguments: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:
+            """Search wiki articles via unified search."""
+            from app.plugins.builtins.unified_search.provider_registry import get_search_registry
+            from app.core.db import get_worker_session_factory
+            query = arguments.get("query", "")
+            tenant_id = context.get("tenant_id")
+            if not query or not tenant_id:
+                return {"error": "query and tenant_id required"}
+            factory = get_worker_session_factory()
+            async with factory() as db:
+                search_registry = get_search_registry()
+                wiki_provider = search_registry.get("wiki_article")
+                if not wiki_provider:
+                    return {"error": "Wiki search provider not available"}
+                results = await wiki_provider._search_fts_filtered(
+                    db=db, tsquery=query, tenant_id=uuid.UUID(str(tenant_id)), limit=5, visible_ids=None
+                )
+                return {
+                    "results": [
+                        {"title": r.get("title", ""), "summary": (r.get("summary") or r.get("content", "")[:200] or "")}
+                        for r in results
+                    ],
+                    "count": len(results),
+                }
+
+        registry.register(
+            name="search_knowledge",
+            description="Search wiki articles by keyword. Returns matching articles with title and summary.",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query"},
+                },
+                "required": ["query"],
+            },
+            handler=_search_knowledge_handler,
+            plugin_name=self.manifest.name,
+            required_permission="wiki:read",
+            category="knowledge",
+        )
+        logger.info("Registered knowledge agent tools: ask_knowledge, search_knowledge")
 
     async def on_deactivate(self, db, service_container, event_bus) -> None:
         """Clean up on deactivation."""
         from app.core.hooks import unregister_actions_by_owner
         unregister_actions_by_owner("knowledge")
+        # Unregister knowledge agent tools from the core AI tool registry
+        try:
+            from app.ai.tool_registry import get_tool_registry
+            get_tool_registry().unregister_plugin(self.manifest.name)
+            logger.info("Unregistered AI agent tools for plugin '%s'", self.manifest.name)
+        except Exception:
+            logger.exception("Failed to unregister AI agent tools")
         await super().on_deactivate(db, service_container, event_bus)