agentify-core 0.2.0__tar.gz → 0.3.1__tar.gz

{agentify_core-0.2.0/agentify_core.egg-info → agentify_core-0.3.1}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.2.0
+Version: 0.3.1
 Summary: Framework-agnostic AI agent library for building single and multi-agent systems
-Author-email: Fabian M <fabian@example.com>
+Author: Fabian M
+Author-email: fabianmp_98@hotmail.com
 License: MIT
 Project-URL: Homepage, https://github.com/fa8i/Agentify
 Project-URL: Repository, https://github.com/fa8i/Agentify
 Project-URL: Bug Tracker, https://github.com/fa8i/Agentify/issues
-Keywords: agent,multi-agent,ai,llm,openai,framework
+Keywords: agentify,agentify-core,agent,multi-agent,ai,llm,openai,framework
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -22,19 +22,26 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: openai>=1.0.0
-Requires-Dist: python-dotenv>=0.19.0
-Requires-Dist: Pillow>=9.0.0
+Requires-Dist: openai
+Requires-Dist: python-dotenv
+Requires-Dist: Pillow
+Requires-Dist: jsonschema>=4.0.0
 Provides-Extra: redis
 Requires-Dist: redis>=4.0.0; extra == "redis"
+Provides-Extra: elastic
+Requires-Dist: elasticsearch>=8.0.0; extra == "elastic"
 Provides-Extra: tools
 Requires-Dist: requests>=2.25.0; extra == "tools"
+Provides-Extra: mcp
+Requires-Dist: mcp; extra == "mcp"
 Provides-Extra: ui
 Requires-Dist: gradio==5.49.1; extra == "ui"
 Provides-Extra: all
 Requires-Dist: redis>=4.0.0; extra == "all"
+Requires-Dist: elasticsearch>=8.0.0; extra == "all"
 Requires-Dist: requests>=2.25.0; extra == "all"
 Requires-Dist: gradio==5.49.1; extra == "all"
+Requires-Dist: mcp; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -47,6 +54,7 @@ Dynamic: license-file
 
 # Agentify
 
+
 **Independent AI agent library based on the OpenAI SDK**
 
 Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.

{agentify_core-0.2.0 → agentify_core-0.3.1}/README.md

@@ -1,40 +1,25 @@
 # Agentify
 
-**Independent AI agent library based on the OpenAI SDK**
-
-Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
-
+[![PyPI version](https://img.shields.io/pypi/v/agentify-core?color=orange)](https://pypi.org/project/agentify-core/)
+[![Downloads](https://img.shields.io/pepy/dt/agentify-core)](https://pepy.tech/project/agentify-core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/agentify-core)](https://pypi.org/project/agentify-core/)
 
-## Why Agentify?
+**Independent AI agent library based on the OpenAI SDK**
 
-- **Built for production**: clear abstractions, explicit configuration, error handling and extension points that map well to real deployments.
-- **Orchestration-first design**: a uniform `run()` interface for agents, teams, pipelines and hierarchies makes it straightforward to compose and refactor flows.
-- **Providers**: switch between OpenAI, Gemini, Azure OpenAI, DeepSeek, Claude and others without changing your agent code.
+Agentify is a Python library for building AI agents and multi-agent systems. Built on the OpenAI-compatible Chat Completions interface, it supports multiple providers (OpenAI, Azure, DeepSeek, Gemini, Claude) with clear abstractions for memory, tools, and orchestration—no heavy framework lock-in.
 
 
 ## Key Features
 
-- **Agents and multi-agent patterns**  
-  Single Agents with tools and memory, supervisor–worker Multi-Agent Teams, Sequential Pipelines where output flows from step to step, Hierarchical Structures for complex delegation, and Dynamic Flows where a controller decides at runtime which sub-agents or teams to invoke.
-
-- **Memory service and isolation**  
-  Pluggable backends (in-memory, Redis, …) with per-use-case policies (TTL, maximum messages, etc.), plus optional memory isolation so each agent can maintain its own conversation history for scalability and privacy.
-
-- **Reasoning Models**  
-  Configure the model's thinking depth, safely merge `model_kwargs`, automatically store
-  "Chain of Thought" in conversation history, and log reasoning steps in real-time for visibility.
-
-- **Tools and actions**  
-  Simple `@tool` decorator for creating tools from functions with automatic JSON Schema generation, or type-annotated tool interface for custom implementations.
-
-- **Observability hooks**  
-  Callback system for logging, monitoring and debugging agent behaviour across complex flows.
-
-- **I/O capabilities**  
-  Streaming support for real-time responses and vision/image models for multimodal interactions.
-
-- **Async & Parallel Execution**  
-  Built-in `async/await` support (`arun()`) for all agents and flows. Automatically executes independent tool calls in parallel (e.g., fetching data from 3 APIs simultaneously), significantly reducing latency.
+- **Multi-agent orchestration**: Teams, pipelines, hierarchies, and dynamic sub-agent spawning
+- **Memory service**: Pluggable backends (in-memory, SQLite, Redis, Elasticsearch) with policies (TTL, limits, token budgets)
+- **Tools**: `@tool` decorator for auto-schema generation, or custom tool classes. Built-in file I/O, planning, weather, and more
+- **MCP Integration**: Easy connection to MCP servers via StdIO (local) or SSE/HTTP (remote) to use external tools
+- **Reasoning models**: Configure thinking depth, store chain-of-thought, real-time reasoning logs
+- **Async & parallel**: `arun()` support with automatic parallel tool and agent execution
+- **Observability**: Callback system for monitoring and debugging
+- **Advanced capabilities**: Dynamic workflows, file/directory operations, complex state management
 
 
 ## Installation
@@ -48,9 +33,11 @@ For optional features:
 pip install agentify-core[all]  # Installs all optional dependencies
 ```
 
-## Quick Start
-
+### Quick Start
 ```python
+# Note: Agentify does not auto-load .env. Load it manually if needed.
+# from dotenv import load_dotenv; load_dotenv()
+
 from agentify import BaseAgent, AgentConfig, MemoryService, MemoryAddress, tool
 from agentify.memory.stores import InMemoryStore
 
@@ -73,7 +60,8 @@ agent = BaseAgent(
         provider="provider",
         model_name="model",
         reasoning_effort="high",  # optional param:"low", "medium", "high"
-        model_kwargs={"max_completion_tokens": 5000} # Pass model-specific params
+        model_kwargs={"max_completion_tokens": 5000}, # Pass model-specific params
+        verbose=True, # Controls logging (True by default)
     ),
     memory=memory,
     memory_address=addr,

{agentify_core-0.2.0 → agentify_core-0.3.1}/README_PYPI.md

@@ -1,5 +1,6 @@
 # Agentify
 
+
 **Independent AI agent library based on the OpenAI SDK**
 
 Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable `base_url` (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.
@@ -112,4 +113,4 @@ MIT License - see the repository for details.
 
 ## Author
 
-**Fabian Melchor** - [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)
+**Fabian Melchor** - [fabianmp_98@hotmail.com](mailto:fabianmp_98@hotmail.com)

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/__init__.py

@@ -11,7 +11,7 @@ from agentify.memory.service import MemoryService
 from agentify.memory.interfaces import MemoryAddress
 from agentify.memory.policies import MemoryPolicy
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"
 
 __all__ = [
     "BaseAgent",

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/core/agent.py

@@ -9,8 +9,11 @@ from io import BytesIO
 import inspect
 from typing import Any, Dict, Generator, List, Optional, Union, Iterator, Callable, AsyncGenerator
 
+from agentify.core.runnable import Runnable
+
 from PIL import Image
 from openai import RateLimitError
+from jsonschema import validate, ValidationError
 
 from agentify.core.tool import Tool
 from agentify.llm.client import LLMClientFactory, LLMClientType, AsyncLLMClientType
@@ -22,12 +25,15 @@ from agentify.core.callbacks import LoggingCallbackHandler
 logger = logging.getLogger(__name__)
 
 
-class BaseAgent:
+class BaseAgent(Runnable):
     """Core AI Agent class based on chat completions interface.
 
     BaseAgent is the primary abstraction for building AI agents in Agentify. It provides
     a unified interface for interacting with various LLM providers (OpenAI, Azure, DeepSeek,
     Gemini, etc.) that implement the OpenAI SDK-compatible chat completions format.
+    
+    It implements the Runnable protocol, making it composable within pipelines and teams.
+
 
     The agent orchestrates the interaction between users, LLMs, and registered tools, managing
     conversation history, tool execution, and model responses. It supports both synchronous
@@ -100,7 +106,7 @@ class BaseAgent:
 
         # Decouple callbacks from config to avoid mutation of shared config
         self.callbacks = list(self.config.callbacks) if self.config.callbacks else []
-        if not self.callbacks:
+        if not self.callbacks and self.config.verbose:
             self.callbacks.append(LoggingCallbackHandler(logger))
 
         self._tools: Dict[str, Tool] = {t.name: t for t in tools or []}
@@ -411,6 +417,38 @@ class BaseAgent:
             )
             raise ValueError(f"Invalid JSON arguments: {exc}")
 
+    def _validate_tool_arguments(self, tool: Tool, arguments: Dict[str, Any]) -> None:
+        """Validate tool arguments against the tool's JSON schema."""
+        if not isinstance(arguments, dict):
+            raise ValueError(f"Tool '{tool.name}' arguments must be a JSON object.")
+
+        params_schema = tool.schema.get("parameters") or {"type": "object"}
+        if "type" not in params_schema:
+            params_schema = {"type": "object", **params_schema}
+
+        try:
+            validate(instance=arguments, schema=params_schema)
+        except ValidationError as exc:
+            raise ValueError(
+                f"Tool '{tool.name}' arguments failed schema validation: {exc.message}"
+            ) from exc
+
+    def _serialize_tool_result(self, result: Any) -> str:
+        """Normalize tool results to a JSON string when possible."""
+        if isinstance(result, bytes):
+            try:
+                return result.decode("utf-8")
+            except UnicodeDecodeError:
+                return base64.b64encode(result).decode("utf-8")
+
+        if isinstance(result, (dict, list)):
+            try:
+                return json.dumps(result, ensure_ascii=False)
+            except TypeError:
+                return json.dumps({"result": str(result)}, ensure_ascii=False)
+
+        return str(result)
+
     def _execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
         """Execute a single tool and return its output as a string."""
         tool = self._tools.get(tool_name)
@@ -425,8 +463,9 @@ class BaseAgent:
             return err_msg
 
         try:
+            self._validate_tool_arguments(tool, arguments)
             result = tool(**arguments)
-            result_str = str(result)
+            result_str = self._serialize_tool_result(result)
             for cb in self.callbacks:
                 cb.on_tool_finish(tool_name, result_str)
             return result_str
@@ -656,7 +695,7 @@ class BaseAgent:
             assembled_tool_calls = self._expand_tool_calls(assembled_tool_calls)
             full_turn_content = "".join(current_turn_content_parts)
 
-            # If no tool calls, we are done
+            # Exit if no tool calls are present
             if not assembled_tool_calls:
                 # Add reasoning to metadata if present
                 msg_kwargs = {}
@@ -721,6 +760,7 @@ class BaseAgent:
         addr: Optional[MemoryAddress] = None,
         image_path: Optional[str] = None,
         image_detail_override: Optional[str] = None,
+        **kwargs: Any,
     ) -> Union[str, Generator[str, None, None]]:
         """Main entrypoint to interact with the agent.
         
@@ -729,10 +769,15 @@ class BaseAgent:
             addr: The memory address for the conversation.
             image_path: Optional path to an image file.
             image_detail_override: Optional detail level for image processing.
+            **kwargs: Additional arguments for compatibility.
             
         Returns:
             The agent's response as a string or a generator if streaming is enabled.
         """
+        # If addr is not provided, try to get it from kwargs (Protocol compatibility)
+        if addr is None and "memory_address" in kwargs:
+             addr = kwargs["memory_address"]
+
         a = self._addr_or_raise(addr)
         response_generator = self._execute_agent_loop(
             user_input,
@@ -852,6 +897,7 @@ class BaseAgent:
             return err_msg
 
         try:
+            self._validate_tool_arguments(tool, arguments)
             # Check for async_func attribute (used by AgentTool, FlowTool, SpawnAgentTool)
             if hasattr(tool, "async_func") and asyncio.iscoroutinefunction(tool.async_func):
                 result = await tool.async_func(**arguments)
@@ -863,7 +909,7 @@ class BaseAgent:
                 result = await asyncio.get_event_loop().run_in_executor(
                     None, lambda: tool(**arguments)
                 )
-            result_str = str(result)
+            result_str = self._serialize_tool_result(result)
             for cb in self.callbacks:
                 cb.on_tool_finish(tool_name, result_str)
             return result_str
@@ -1004,7 +1050,7 @@ class BaseAgent:
             assembled_tool_calls = self._expand_tool_calls(assembled_tool_calls)
             full_turn_content = "".join(current_turn_content_parts)
 
-            # If no tool calls, we are done
+            # Exit if no tool calls are present
             if not assembled_tool_calls:
                 msg_kwargs = {}
                 if full_reasoning_content:
@@ -1032,7 +1078,13 @@ class BaseAgent:
                 args_str = tc["function"]["arguments"]
                 try:
                     args = self._parse_tool_arguments(tool_name, args_str)
-                    result_content = await self._aexecute_tool(tool_name, args)
+                    # Add timeout to prevent indefinite hangs
+                    result_content = await asyncio.wait_for(
+                        self._aexecute_tool(tool_name, args),
+                        timeout=60.0  # Default 60s timeout for tools
+                    )
+                except asyncio.TimeoutError:
+                    result_content = json.dumps({"error": f"Tool '{tool_name}' execution timed out after 60 seconds."})
                 except ValueError as e:
                     result_content = json.dumps({"error": str(e)})
                 return tool_call_id, tool_name, result_content
@@ -1071,6 +1123,7 @@ class BaseAgent:
         addr: Optional[MemoryAddress] = None,
         image_path: Optional[str] = None,
         image_detail_override: Optional[str] = None,
+        **kwargs: Any,
     ) -> Union[str, AsyncGenerator[str, None]]:
         """Async entrypoint to interact with the agent.
         
@@ -1083,11 +1136,17 @@ class BaseAgent:
             addr: The memory address for the conversation.
             image_path: Optional path to an image file.
             image_detail_override: Optional detail level for image processing.
+            **kwargs: Additional arguments for compatibility.
             
         Returns:
             The agent's response as a string or an async generator if streaming is enabled.
         """
+        # If addr is not provided, try to get it from kwargs (Protocol compatibility)
+        if addr is None and "memory_address" in kwargs:
+             addr = kwargs["memory_address"]
+
         a = self._addr_or_raise(addr)
+
         response_generator = self._aexecute_agent_loop(
             user_input,
             addr=a,

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/core/callbacks.py

@@ -50,20 +50,48 @@ class LoggingCallbackHandler(AgentCallbackHandler):
 
     def __init__(self, logger_instance: Optional[logging.Logger] = None):
         self.logger = logger_instance or logger
+        self.redact_keys = {"password", "api_key", "token", "secret", "key", "authorization"}
+
+        # Auto-configure handler if none exists
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setLevel(logging.INFO)
+            self.logger.addHandler(handler)
+            self.logger.setLevel(logging.INFO)
+
+    def _mask_secrets(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Recursively mask sensitive keys in a dictionary."""
+        masked = {}
+        for k, v in data.items():
+            if k.lower() in self.redact_keys:
+                masked[k] = "******"
+            elif isinstance(v, dict):
+                masked[k] = self._mask_secrets(v)
+            else:
+                masked[k] = v
+        return masked
 
     def on_agent_start(self, agent_name: str, user_input: str) -> None:
-        self.logger.info(f"Agent '{agent_name}' started. Input: {user_input[:100]}...")
+        self.logger.info(
+            f"{Colors.BLUE}[VERBOSE] Agent '{agent_name}' started.{Colors.RESET} Input: {user_input[:100]}..."
+        )
 
     def on_agent_finish(self, agent_name: str, response: str) -> None:
         self.logger.info(
-            f"Agent '{agent_name}' finished. Response: {response[:100]}..."
+            f"{Colors.BLUE}[VERBOSE] Agent '{agent_name}' finished.{Colors.RESET} Response: {response[:100]}..."
         )
 
     def on_tool_start(self, tool_name: str, args: Dict[str, Any]) -> None:
-        self.logger.info(f"Tool '{tool_name}' started. Args: {args}")
+        # Redact sensitive values
+        safe_args = self._mask_secrets(args)
+        self.logger.info(
+            f"{Colors.CYAN}[VERBOSE] Tool '{tool_name}' started.{Colors.RESET} Args: {safe_args}"
+        )
 
     def on_tool_finish(self, tool_name: str, output: str) -> None:
-        self.logger.info(f"Tool '{tool_name}' finished. Output: {output[:100]}...")
+        self.logger.info(
+            f"{Colors.CYAN}[VERBOSE] Tool '{tool_name}' finished.{Colors.RESET} Output: {output[:100]}..."
+        )
 
     def on_llm_start(self, model_name: str, messages: List[Dict[str, Any]]) -> None:
         self.logger.debug(f"LLM '{model_name}' started. Messages: {len(messages)}")

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/core/config.py

@@ -21,6 +21,7 @@ class AgentConfig:
     timeout: int = 60
     stream: bool = False
     max_retries: int = 3
+    verbose: bool = True
     max_tool_iter: Optional[int] = 10
     reasoning_effort: Optional[str] = None
     model_kwargs: Optional[Dict[str, Any]] = None

agentify_core-0.3.1/agentify/core/runnable.py

@@ -0,0 +1,20 @@
+from typing import Protocol, Any, Dict, Optional, Generator, AsyncGenerator, Union
+
+class Runnable(Protocol):
+    """Standard interface for any chainable unit/agent in Agentify."""
+
+    def run(
+        self,
+        user_input: str,
+        **kwargs: Any
+    ) -> Union[str, Generator[str, None, None]]:
+        """Synchronous execution."""
+        ...
+
+    async def arun(
+        self,
+        user_input: str,
+        **kwargs: Any
+    ) -> Union[str, AsyncGenerator[str, None]]:
+        """Asynchronous execution."""
+        ...

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/core/tool.py

@@ -19,10 +19,10 @@ class Tool:
     def name(self) -> str:
         return self.schema["name"]
 
-    def __call__(self, **kwargs: Any) -> str:
+    def __call__(self, *args: Any, **kwargs: Any) -> str:
         """Executes the function and returns JSON or string; captures generic errors."""
         try:
-            result = self.func(**kwargs)
+            result = self.func(*args, **kwargs)
         except Exception as exc:  # noqa: BLE001
             return json.dumps({"error": str(exc)}, ensure_ascii=False)
 

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/extensions/tools/filesystem.py

@@ -2,24 +2,32 @@ import os
 from typing import Any, Dict, List, Optional
 from agentify.core.tool import Tool
 
+DEFAULT_MAX_READ_BYTES = 1024 * 1024
+HARD_MAX_READ_BYTES = 5 * 1024 * 1024
+
 class BaseFilesystemTool(Tool):
     """Base class for filesystem tools with sandbox security."""
     
     def __init__(self, schema: Dict[str, Any], func: Any, sandbox_dir: Optional[str] = None):
         super().__init__(schema, func)
-        # If no sandbox provided, default to current working directory or a safe temp dir could be better 
-        # but for this agent library, let's default to CWD but allow override.
+        # Default to current working directory if no sandbox is provided.
         self.sandbox_dir = os.path.abspath(sandbox_dir or os.getcwd())
 
     def _validate_path(self, file_path: str) -> str:
         """Ensure path is within sandbox."""
-        # Handle absolute paths by checking if they start with sandbox
-        abs_path = os.path.abspath(os.path.join(self.sandbox_dir, file_path))
+        # Resolve user path relative to sandbox.
+        # Note: os.path.join discards sandbox_dir if file_path is absolute.
+        full_path = os.path.join(self.sandbox_dir, file_path)
         
-        if not abs_path.startswith(self.sandbox_dir):
-            raise ValueError(f"Access denied: Path '{file_path}' is outside sandbox directory '{self.sandbox_dir}'")
+        # Resolve symlinks and .. components
+        real_path = os.path.realpath(full_path)
+        real_sandbox = os.path.realpath(self.sandbox_dir)
+
+        # Check if the resolved path starts with the resolved sandbox path
+        if os.path.commonpath([real_sandbox, real_path]) != real_sandbox:
+             raise ValueError(f"Access denied: Path '{file_path}' resolves to '{real_path}', which is outside sandbox '{real_sandbox}'")
         
-        return abs_path
+        return real_path
 
 
 class ListDirTool(BaseFilesystemTool):
@@ -70,21 +78,38 @@ class ReadFileTool(BaseFilesystemTool):
                     "file_path": {
                         "type": "string",
                         "description": "Path to the file to read.",
-                    }
+                    },
+                    "max_bytes": {
+                        "type": "integer",
+                        "description": "Maximum bytes to read from the file (hard-capped).",
+                    },
                 },
                 "required": ["file_path"],
             },
         }
         super().__init__(schema, self._read_file, sandbox_dir)
 
-    def _read_file(self, file_path: str) -> str:
+    def _read_file(self, file_path: str, max_bytes: Optional[int] = None) -> str:
         try:
             target_path = self._validate_path(file_path)
             if not os.path.exists(target_path):
                 return f"Error: File '{file_path}' does not exist."
-            
-            with open(target_path, "r", encoding="utf-8") as f:
-                return f.read()
+
+            if max_bytes is not None and max_bytes <= 0:
+                return "Error: 'max_bytes' must be a positive integer."
+
+            read_limit = min(max_bytes or DEFAULT_MAX_READ_BYTES, HARD_MAX_READ_BYTES)
+
+            with open(target_path, "rb") as f:
+                content = f.read(read_limit + 1)
+
+            truncated = len(content) > read_limit
+            text = content[:read_limit].decode("utf-8", errors="replace")
+
+            if truncated:
+                return f"{text}\n[Truncated to {read_limit} bytes]"
+
+            return text
         except Exception as e:
             return f"Error reading file: {str(e)}"
 

{agentify_core-0.2.0 → agentify_core-0.3.1}/agentify/llm/client.py

@@ -3,7 +3,7 @@ from dotenv import load_dotenv
 from typing import Union, Dict, Any, Optional, Callable
 from openai import OpenAI, AzureOpenAI, AsyncOpenAI, AsyncAzureOpenAI
 
-load_dotenv()
+# load_dotenv()  # Removed to avoid side effects on import
 
 LLMClientType = Union[OpenAI, AzureOpenAI]
 AsyncLLMClientType = Union[AsyncOpenAI, AsyncAzureOpenAI]

agentify_core-0.3.1/agentify/mcp/__init__.py

@@ -0,0 +1,3 @@
+from agentify.mcp.client import MCPConnection
+
+__all__ = ["MCPConnection"]

agentify_core-0.3.1/agentify/mcp/adapter.py

@@ -0,0 +1,46 @@
+"""Adapter to convert MCP tools into Agentify Tool objects."""
+from typing import Any, Callable, List
+from mcp import ClientSession
+from agentify.core.tool import Tool
+
+
+async def convert_mcp_tools_to_agentify(
+    session: ClientSession,
+    mcp_tools: List[Any],
+) -> List[Tool]:
+    """Transforms MCP tools into Agentify-compatible Tool objects."""
+    agentify_tools: List[Tool] = []
+
+    for m_tool in mcp_tools:
+        schema = {
+            "name": m_tool.name,
+            "description": m_tool.description or "",
+            "parameters": m_tool.inputSchema,
+        }
+        wrapper = _create_tool_wrapper(session, m_tool.name)
+        agentify_tools.append(Tool(schema=schema, func=wrapper))
+
+    return agentify_tools
+
+
+def _create_tool_wrapper(session: ClientSession, tool_name: str) -> Callable[..., Any]:
+    """Creates an async wrapper function that calls the MCP server."""
+
+    async def _mcp_tool_wrapper(**kwargs: Any) -> Any:
+        result = await session.call_tool(tool_name, arguments=kwargs)
+
+        output_parts = []
+        if result.content:
+            for item in result.content:
+                if item.type == "text":
+                    output_parts.append(item.text)
+                elif item.type == "image":
+                    output_parts.append(f"[Image: {item.mimeType}]")
+                elif item.type == "resource":
+                    output_parts.append(f"[Resource: {item.resource.uri}]")
+
+        return "\n".join(output_parts)
+
+    _mcp_tool_wrapper.__name__ = tool_name
+    _mcp_tool_wrapper.__doc__ = f"MCP Tool: {tool_name}"
+    return _mcp_tool_wrapper