Gl/fix 30 version (#84)

* fix lint

* update postgres

* Update code

* update version

Author: GuanyiLi-Craig

grafi/tools/tool_factory.py

@@ -11,18 +11,8 @@
 from typing import Type
 
 from grafi.tools.function_calls.function_call_tool import FunctionCallTool
-from grafi.tools.function_calls.impl.agent_calling_tool import AgentCallingTool
-from grafi.tools.function_calls.impl.duckduckgo_tool import DuckDuckGoTool
-from grafi.tools.function_calls.impl.google_search_tool import GoogleSearchTool
-from grafi.tools.function_calls.impl.mcp_tool import MCPTool
-from grafi.tools.function_calls.impl.tavily_tool import TavilyTool
 from grafi.tools.functions.function_tool import FunctionTool
-from grafi.tools.llms.impl.claude_tool import ClaudeTool
-from grafi.tools.llms.impl.deepseek_tool import DeepseekTool
-from grafi.tools.llms.impl.gemini_tool import GeminiTool
-from grafi.tools.llms.impl.ollama_tool import OllamaTool
 from grafi.tools.llms.impl.openai_tool import OpenAITool
-from grafi.tools.llms.impl.openrouter_tool import OpenRouterTool
 from grafi.tools.tool import Tool
 
 
@@ -55,17 +45,6 @@ class to instantiate, then delegates to that class's from_dict() method.
         "FunctionTool": FunctionTool,
         # LLM implementations
         "OpenAITool": OpenAITool,
-        "ClaudeTool": ClaudeTool,
-        "DeepseekTool": DeepseekTool,
-        "GeminiTool": GeminiTool,
-        "OllamaTool": OllamaTool,
-        "OpenRouterTool": OpenRouterTool,
-        # FunctionCall implementations
-        "TavilyTool": TavilyTool,
-        "DuckDuckGoTool": DuckDuckGoTool,
-        "GoogleSearchTool": GoogleSearchTool,
-        "MCPTool": MCPTool,
-        "AgentCallingTool": AgentCallingTool,
     }
 
     @classmethod

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "grafi"
-version = "0.0.30"
+version = "0.0.31"
 description = "Grafi - a flexible, event-driven framework that enables the creation of domain-specific AI agents through composable agentic workflows."
 authors = [{name = "Craig Li", email = "craig@binome.dev"}]
 license = {text = "Mozilla Public License Version 2.0"}

tests/tools/test_tool_factory.py

@@ -6,6 +6,7 @@
 
 import pytest
 
+from grafi.tools.function_calls.function_call_tool import FunctionCallTool
 from grafi.tools.function_calls.impl.duckduckgo_tool import DuckDuckGoTool
 from grafi.tools.function_calls.impl.tavily_tool import TavilyTool
 from grafi.tools.llms.impl.claude_tool import ClaudeTool
@@ -44,6 +45,7 @@ async def test_tool_factory_openai_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_claude_tool():
     """Test factory creates ClaudeTool correctly."""
+    ToolFactory.register_tool_class("ClaudeTool", ClaudeTool)
     data = {
         "class": "ClaudeTool",
         "tool_id": "test-id",
@@ -69,6 +71,7 @@ async def test_tool_factory_claude_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_deepseek_tool():
     """Test factory creates DeepseekTool correctly."""
+    ToolFactory.register_tool_class("DeepseekTool", DeepseekTool)
     data = {
         "class": "DeepseekTool",
         "tool_id": "test-id",
@@ -93,6 +96,7 @@ async def test_tool_factory_deepseek_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_gemini_tool():
     """Test factory creates GeminiTool correctly."""
+    ToolFactory.register_tool_class("GeminiTool", GeminiTool)
     data = {
         "class": "GeminiTool",
         "tool_id": "test-id",
@@ -116,6 +120,7 @@ async def test_tool_factory_gemini_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_ollama_tool():
     """Test factory creates OllamaTool correctly."""
+    ToolFactory.register_tool_class("OllamaTool", OllamaTool)
     data = {
         "class": "OllamaTool",
         "tool_id": "test-id",
@@ -140,6 +145,7 @@ async def test_tool_factory_ollama_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_openrouter_tool():
     """Test factory creates OpenRouterTool correctly."""
+    ToolFactory.register_tool_class("OpenRouterTool", OpenRouterTool)
     data = {
         "class": "OpenRouterTool",
         "tool_id": "test-id",
@@ -165,6 +171,7 @@ async def test_tool_factory_openrouter_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_duckduckgo_tool():
     """Test factory creates DuckDuckGoTool correctly."""
+    ToolFactory.register_tool_class("DuckDuckGoTool", DuckDuckGoTool)
     data = {
         "class": "DuckDuckGoTool",
         "tool_id": "test-id",
@@ -185,6 +192,7 @@ async def test_tool_factory_duckduckgo_tool():
 @pytest.mark.asyncio
 async def test_tool_factory_tavily_tool():
     """Test factory creates TavilyTool correctly."""
+    ToolFactory.register_tool_class("TavilyTool", TavilyTool)
     # Set a dummy API key for test
     os.environ["TAVILY_API_KEY"] = "test_key"
 
@@ -261,6 +269,7 @@ async def test_tool_factory_roundtrip_openai():
 async def test_tool_factory_roundtrip_claude():
     """Test serialization and deserialization roundtrip for ClaudeTool."""
     # Create original tool using builder
+    ToolFactory.register_tool_class("ClaudeTool", ClaudeTool)
     original = (
         ClaudeTool.builder()
         .name("test_claude")
@@ -340,7 +349,6 @@ async def from_dict(cls, data):
 def test_tool_factory_is_registered():
     """Test checking if a class is registered."""
     assert ToolFactory.is_registered("OpenAITool")
-    assert ToolFactory.is_registered("ClaudeTool")
     assert not ToolFactory.is_registered("NonExistentTool")
 
 
@@ -350,15 +358,9 @@ def test_tool_factory_get_registered_classes():
 
     # Check some expected classes are in the registry
     assert "OpenAITool" in registered
-    assert "ClaudeTool" in registered
-    assert "DeepseekTool" in registered
-    assert "GeminiTool" in registered
-    assert "OllamaTool" in registered
-    assert "OpenRouterTool" in registered
-    assert "TavilyTool" in registered
-    assert "DuckDuckGoTool" in registered
+    assert "FunctionCallTool" in registered
     assert "FunctionTool" in registered
 
     # Verify the classes are correct
     assert registered["OpenAITool"] == OpenAITool
-    assert registered["ClaudeTool"] == ClaudeTool
+    assert registered["FunctionCallTool"] == FunctionCallTool

tests_integration/mcp_assistant/mpc_deserialize_assistant_example_local.py

@@ -8,6 +8,8 @@
 from grafi.common.events.topic_events.publish_to_topic_event import PublishToTopicEvent
 from grafi.common.models.invoke_context import InvokeContext
 from grafi.common.models.message import Message
+from grafi.tools.function_calls.impl.mcp_tool import MCPTool
+from grafi.tools.tool_factory import ToolFactory
 
 
 def get_invoke_context() -> InvokeContext:
@@ -28,6 +30,7 @@ async def test_deserialized_assistant() -> None:
     with open(Path(__file__).parent / "MCPAssistant_manifest.json", "r") as f:
         manifest_json = f.read()
 
+    ToolFactory.register_tool_class("MCPTool", MCPTool)
     # Deserialize the assistant using the new method
     assistant = await Assistant.from_dict(json.loads(manifest_json))
 

tests_integration/react_assistant/react_assistant_deserialize_assistant_example.py

@@ -7,6 +7,8 @@
 from grafi.common.events.topic_events.publish_to_topic_event import PublishToTopicEvent
 from grafi.common.models.invoke_context import InvokeContext
 from grafi.common.models.message import Message
+from grafi.tools.function_calls.impl.tavily_tool import TavilyTool
+from grafi.tools.tool_factory import ToolFactory
 
 
 def get_invoke_context() -> InvokeContext:
@@ -24,6 +26,7 @@ async def test_deserialized_assistant() -> None:
         manifest_json = f.read()
 
     # Deserialize the assistant using the new method
+    ToolFactory.register_tool_class("TavilyTool", TavilyTool)
     assistant = await Assistant.from_dict(json.loads(manifest_json))
 
     print(f"Successfully deserialized assistant: {assistant.name}")

tests_integration/simple_llm_assistant/claude_tool_example.py

@@ -161,6 +161,7 @@ async def test_claude_tool_serialization() -> None:
     print(f"Serialized: {serialized}")
 
     # Deserialize back using ToolFactory
+    ToolFactory.register_tool_class("ClaudeTool", ClaudeTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works correctly
@@ -198,6 +199,7 @@ async def test_claude_tool_with_chat_param_serialization() -> None:
     serialized = original_tool.to_dict()
 
     # Deserialize back
+    ToolFactory.register_tool_class("ClaudeTool", ClaudeTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works

tests_integration/simple_llm_assistant/deepseek_tool_example.py

@@ -151,6 +151,7 @@ async def test_deepseek_tool_serialization() -> None:
     print(f"Serialized: {serialized}")
 
     # Deserialize back using ToolFactory
+    ToolFactory.register_tool_class("DeepseekTool", DeepseekTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works correctly
@@ -184,6 +185,7 @@ async def test_deepseek_tool_with_chat_param_serialization() -> None:
     serialized = original_tool.to_dict()
 
     # Deserialize back
+    ToolFactory.register_tool_class("DeepseekTool", DeepseekTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works

tests_integration/simple_llm_assistant/gemini_tool_example.py

@@ -152,6 +152,7 @@ async def test_gemini_tool_serialization() -> None:
     print(f"Serialized: {serialized}")
 
     # Deserialize back using ToolFactory
+    ToolFactory.register_tool_class("GeminiTool", GeminiTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works correctly
@@ -188,6 +189,7 @@ async def test_gemini_tool_with_chat_param_serialization() -> None:
     serialized = original_tool.to_dict()
 
     # Deserialize back
+    ToolFactory.register_tool_class("GeminiTool", GeminiTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works

tests_integration/simple_llm_assistant/openrouter_tool_example.py

@@ -146,6 +146,7 @@ async def test_openrouter_tool_serialization() -> None:
     print(f"Serialized: {serialized}")
 
     # Deserialize back using ToolFactory
+    ToolFactory.register_tool_class("OpenRouterTool", OpenRouterTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works correctly
@@ -179,6 +180,7 @@ async def test_openrouter_tool_with_chat_param_serialization() -> None:
     serialized = original_tool.to_dict()
 
     # Deserialize back
+    ToolFactory.register_tool_class("OpenRouterTool", OpenRouterTool)
     restored_tool = await ToolFactory.from_dict(serialized)
 
     # Test that the restored tool works