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

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.3.0
+Version: 0.3.1
 Summary: Framework-agnostic AI agent library for building single and multi-agent systems
-Author-email: Fabian M <fabianmp_98@hotmail.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
@@ -24,6 +25,7 @@ License-File: LICENSE
 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

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

@@ -33,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
 
@@ -58,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.3.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.3.0"
+__version__ = "0.3.1"
 
 __all__ = [
     "BaseAgent",

{agentify_core-0.3.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.3.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.3.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.3.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.3.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.3.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.0 → agentify_core-0.3.1}/agentify/memory/interfaces.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Protocol, Tuple
 from datetime import datetime, timezone
 import uuid
+from urllib.parse import quote
 
 
 @dataclass(frozen=True, slots=True)
@@ -30,15 +31,23 @@ class MemoryAddress:
             self.extras,
         )
 
+    def _encode_part(self, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return None
+        return quote(value, safe="")
+
+    def _encode_key(self, key: str) -> str:
+        return quote(key, safe="")
+
     def key_str(self, prefix: str = "mem") -> str:
         """Human-readable key for key-value backends (e.g., Redis)."""
         parts = [
-            ("v", self.api_version),
-            ("t", self.tenant_id),
-            ("u", self.user_id),
-            ("c", self.conversation_id),
-            ("a", self.agent_id),
-        ] + list(self.extras)
+            ("v", self._encode_part(self.api_version)),
+            ("t", self._encode_part(self.tenant_id)),
+            ("u", self._encode_part(self.user_id)),
+            ("c", self._encode_part(self.conversation_id)),
+            ("a", self._encode_part(self.agent_id)),
+        ] + [(self._encode_key(k), self._encode_part(v)) for k, v in self.extras]
         joined = ":".join(f"{k}={v}" for k, v in parts if v)
         return f"{prefix}:{joined}" if joined else prefix
 
@@ -67,7 +76,12 @@ class Message:
             d["name"] = self.name
         if self.tool_call_id is not None:
             d["tool_call_id"] = self.tool_call_id
-        d.update(self.metadata)  # carry extra fields (e.g., tool_calls)
+        
+        # Merge metadata but do NOT overwrite reserved keys
+        reserved = {"role", "content", "name", "tool_call_id"}
+        for k, v in self.metadata.items():
+            if k not in reserved:
+                d[k] = v
         return d
 
     def to_dict(self) -> Dict[str, Any]:

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/memory/service.py

@@ -27,12 +27,13 @@ class MemoryService:
         store: ConversationStore,
         policy: Optional[MemoryPolicy] = None,
         log_enabled: bool = True,
-        max_log_length: Optional[int] = None,
+        max_log_length: Optional[int] = 5000,
     ) -> None:
         self.store = store
         self.policy = policy or MemoryPolicy(store)
         self.log_enabled = log_enabled
-        self.max_log_length = max_log_length # max length preview of the log
+        self.max_log_length = max_log_length  # max length preview of the log
+        self.redact_keys = {"password", "api_key", "token", "secret", "key", "authorization"}
 
     def _normalize_message(self, message: Dict[str, Any]) -> Message:
         """Accept OpenAI-shaped dicts; move unknown keys (e.g., 'tool_calls') into metadata.
@@ -53,6 +54,26 @@ class MemoryService:
         base["metadata"] = meta
         return Message(**base)
 
+    def _mask_secrets(self, value: Any) -> Any:
+        if isinstance(value, dict):
+            masked: Dict[str, Any] = {}
+            for k, v in value.items():
+                if k.lower() in self.redact_keys:
+                    masked[k] = "******"
+                else:
+                    masked[k] = self._mask_secrets(v)
+            return masked
+        if isinstance(value, list):
+            return [self._mask_secrets(item) for item in value]
+        return value
+
+    def _preview_content(self, content: Any) -> Any:
+        redacted = self._mask_secrets(content)
+        if isinstance(redacted, str) and self.max_log_length is not None:
+            if len(redacted) > self.max_log_length:
+                return redacted[: self.max_log_length] + "..."
+        return redacted
+
     def append_history(self, addr: MemoryAddress, message: Dict[str, Any]) -> None:
         """Append a dict message (OpenAI-ish) to the given address, normalizing extras."""
         msg = self._normalize_message(message)
@@ -85,20 +106,14 @@ class MemoryService:
                     f"{Colors.GRAY}{agent_tag}{Colors.RESET}{Colors.GRAY}[Reasoning]{Colors.RESET} {Colors.GRAY}{reasoning_preview}{Colors.RESET}"
                 )
 
-            if self.max_log_length is None:
-                content_preview = msg.content
-            else:
-                content_preview = (
-                    (msg.content[: self.max_log_length] + "...")
-                    if msg.content and len(msg.content) > self.max_log_length
-                    else msg.content
-                )
+            content_preview = self._preview_content(msg.content)
 
             tool_info = ""
             if msg.metadata and "tool_calls" in msg.metadata:
+                tool_calls = self._mask_secrets(msg.metadata["tool_calls"])
                 tool_names = [
                     tc.get("function", {}).get("name", "unknown")
-                    for tc in msg.metadata["tool_calls"]
+                    for tc in tool_calls
                 ]
                 tool_info = (
                     f"{Colors.MAGENTA} | tools: {', '.join(tool_names)}{Colors.RESET}"

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/memory/stores/elastic_store.py

@@ -3,6 +3,7 @@ import json
 import logging
 from typing import List, Optional, Any, Dict
 from datetime import datetime
+from urllib.parse import unquote
 
 try:
     from elasticsearch import Elasticsearch
@@ -120,9 +121,8 @@ class ElasticsearchStore(ConversationStore):
     def read_messages(self, addr: MemoryAddress, start: int = 0, end: int = -1) -> List[Message]:
         must = self._build_filter_query(addr)
         
-        # We need to fetch enough messages to support the slice.
-        # Since 'end' can be -1 (all), we might need a large size or scroll.
-        # For chat history, usually 100-1000 is enough.
+        # Fetch enough messages to support the slice.
+        # If 'end' is -1 (all), a large size or scroll might be required.
         size = 1000 if end == -1 else (end + 20)
 
         query = {
@@ -183,9 +183,9 @@ class ElasticsearchStore(ConversationStore):
         self.client.delete_by_query(index=self.index_name, body=query, refresh=True)
 
     def set_ttl(self, addr: MemoryAddress, seconds: int) -> None:
-        # Implementing TTL in ES usually requires Index Lifecycle Management (ILM) 
-        # or a separate cleanup job, as TTL is per-index or per-document requires setup.
-        # For simplicity, we log strictly: This is not natively supported per-conversation efficiently.
+        # Implementing TTL in ES typically requires Index Lifecycle Management (ILM)
+        # or a separate cleanup job.
+        # Log warning as this is not natively supported per-conversation efficiently.
         logger.warning("set_ttl is not fully supported in simple ElasticsearchStore yet.")
 
     def list_conversations(self, limit: int = 100, offset: int = 0) -> List[MemoryAddress]:
@@ -228,13 +228,15 @@ class ElasticsearchStore(ConversationStore):
                 if "=" not in part:
                     continue
                 key, val = part.split("=", 1)
-                if key == "v": kwargs["api_version"] = val
-                elif key == "t": kwargs["tenant_id"] = val
-                elif key == "u": kwargs["user_id"] = val
-                elif key == "c": kwargs["conversation_id"] = val
-                elif key == "a": kwargs["agent_id"] = val
+                decoded_key = unquote(key)
+                decoded_val = unquote(val)
+                if decoded_key == "v": kwargs["api_version"] = decoded_val
+                elif decoded_key == "t": kwargs["tenant_id"] = decoded_val
+                elif decoded_key == "u": kwargs["user_id"] = decoded_val
+                elif decoded_key == "c": kwargs["conversation_id"] = decoded_val
+                elif decoded_key == "a": kwargs["agent_id"] = decoded_val
                 else:
-                    extras.append((key, val))
+                    extras.append((decoded_key, decoded_val))
             
             if extras:
                 kwargs["extras"] = tuple(extras)

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/memory/stores/redis_store.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import json
 from typing import List
+from urllib.parse import unquote
 
 try:
     import redis
@@ -80,13 +81,15 @@ class RedisStore(ConversationStore):
                 if "=" not in part:
                     continue
                 key, val = part.split("=", 1)
-                if key == "v": kwargs["api_version"] = val
-                elif key == "t": kwargs["tenant_id"] = val
-                elif key == "u": kwargs["user_id"] = val
-                elif key == "c": kwargs["conversation_id"] = val
-                elif key == "a": kwargs["agent_id"] = val
+                decoded_key = unquote(key)
+                decoded_val = unquote(val)
+                if decoded_key == "v": kwargs["api_version"] = decoded_val
+                elif decoded_key == "t": kwargs["tenant_id"] = decoded_val
+                elif decoded_key == "u": kwargs["user_id"] = decoded_val
+                elif decoded_key == "c": kwargs["conversation_id"] = decoded_val
+                elif decoded_key == "a": kwargs["agent_id"] = decoded_val
                 else:
-                    extras.append((key, val))
+                    extras.append((decoded_key, decoded_val))
             
             if extras:
                 kwargs["extras"] = tuple(extras)

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/memory/stores/sqlite_store.py

@@ -3,6 +3,7 @@ import sqlite3
 import json
 import logging
 from typing import List, Tuple, Any
+from urllib.parse import unquote
 from ..interfaces import ConversationStore, MemoryAddress, Message
 
 logger = logging.getLogger(__name__)
@@ -178,13 +179,15 @@ class SQLiteStore(ConversationStore):
                     if "=" not in part:
                         continue
                     k, v = part.split("=", 1)
-                    if k == "v": kwargs["api_version"] = v
-                    elif k == "t": kwargs["tenant_id"] = v
-                    elif k == "u": kwargs["user_id"] = v
-                    elif k == "c": kwargs["conversation_id"] = v
-                    elif k == "a": kwargs["agent_id"] = v
+                    decoded_key = unquote(k)
+                    decoded_val = unquote(v)
+                    if decoded_key == "v": kwargs["api_version"] = decoded_val
+                    elif decoded_key == "t": kwargs["tenant_id"] = decoded_val
+                    elif decoded_key == "u": kwargs["user_id"] = decoded_val
+                    elif decoded_key == "c": kwargs["conversation_id"] = decoded_val
+                    elif decoded_key == "a": kwargs["agent_id"] = decoded_val
                     else:
-                        extras.append((k, v))
+                        extras.append((decoded_key, decoded_val))
                 
                 if extras:
                     kwargs["extras"] = tuple(extras)

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/multi_agent/hierarchical.py

@@ -1,10 +1,11 @@
-from typing import Dict, List, Union, Generator, AsyncGenerator
+from typing import Dict, List, Union, Generator, AsyncGenerator, Any, Optional
+from agentify.core.runnable import Runnable
 from agentify.core.agent import BaseAgent
 from agentify.memory.interfaces import MemoryAddress
 from agentify.multi_agent.tool_wrapper import AgentTool, FlowTool, Flow
 
 
-class HierarchicalTeam:
+class HierarchicalTeam(Runnable):
     """Orchestrates a hierarchy of agents (Tree structure).
 
     - Root agent is the entry point.
@@ -30,6 +31,8 @@ class HierarchicalTeam:
         user_input: str,
         session_id: str = "default_session",
         user_id: str = "default_user",
+        context: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
     ) -> Union[str, Generator[str, None, None]]:
         """Run the hierarchical flow."""
 
@@ -51,6 +54,8 @@ class HierarchicalTeam:
         user_input: str,
         session_id: str = "default_session",
         user_id: str = "default_user",
+        context: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
     ) -> Union[str, AsyncGenerator[str, None]]:
         """Async version of run(). Uses root agent's arun() for async execution."""
 

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/multi_agent/pipeline.py

@@ -1,14 +1,12 @@
-from typing import List, Union, Generator, Any, AsyncGenerator
-
-from agentify.core.agent import BaseAgent
+from typing import List, Union, Generator, Any, AsyncGenerator, Optional, Dict
+from agentify.core.runnable import Runnable
 from agentify.memory.interfaces import MemoryAddress
-from agentify.multi_agent.team import Team
 
 # Type alias for what can be a step in the pipeline
-PipelineStep = Union[BaseAgent, Team, "SequentialPipeline", Any]
+PipelineStep = Runnable
 
 
-class SequentialPipeline:
+class SequentialPipeline(Runnable):
     """Executes a sequence of agents/teams/pipelines in order.
 
     The output of step N becomes the input of step N+1.
@@ -24,6 +22,8 @@ class SequentialPipeline:
         user_input: str,
         session_id: str = "default_session",
         user_id: str = "default_user",
+        context: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
     ) -> Union[str, Generator[str, None, None]]:
         """Run the pipeline sequentially."""
 
@@ -40,21 +40,22 @@ class SequentialPipeline:
 
             response: Union[str, Generator[str, None, None]]
 
-            if isinstance(step, BaseAgent):
-                step_addr = MemoryAddress(
+            # Pass session info for unified Runnable execution.
+            # Support legacy agents by constructing a MemoryAddress if applicable.
+            run_kwargs = {
+                "session_id": session_id, 
+                "user_id": user_id,
+                "context": context
+            }
+            # Add explicit memory address for BaseAgents (legacy support within Runnable)
+            if hasattr(step, "config") and hasattr(step, "run"):
+                 run_kwargs["memory_address"] = MemoryAddress(
                     user_id=user_id, conversation_id=session_id, agent_id=step_name
                 )
-                response = step.run(user_input=current_input, addr=step_addr)
+            
+            run_kwargs.update(kwargs) # Pass through any other kwargs
 
-            elif hasattr(step, "run"):
-                # Team, SequentialPipeline, HierarchicalTeam
-                response = step.run(
-                    user_input=current_input, session_id=session_id, user_id=user_id
-                )
-            else:
-                raise ValueError(
-                    f"Step {i} ({type(step)}) is not a valid agent or flow."
-                )
+            response = step.run(user_input=current_input, **run_kwargs)
 
             # If not last step, consume output to pass to next step
             if not is_last_step:
@@ -72,6 +73,8 @@ class SequentialPipeline:
         user_input: str,
         session_id: str = "default_session",
         user_id: str = "default_user",
+        context: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
     ) -> Union[str, AsyncGenerator[str, None]]:
         """Async version of run(). Sequentially awaits each step."""
 
@@ -86,26 +89,20 @@ class SequentialPipeline:
 
             response: Union[str, AsyncGenerator[str, None]]
 
-            if isinstance(step, BaseAgent):
-                step_addr = MemoryAddress(
+            # Async execution
+            run_kwargs = {
+                "session_id": session_id, 
+                "user_id": user_id,
+                "context": context
+            }
+            if hasattr(step, "config") and hasattr(step, "arun"):
+                 run_kwargs["memory_address"] = MemoryAddress(
                     user_id=user_id, conversation_id=session_id, agent_id=step_name
                 )
-                response = await step.arun(user_input=current_input, addr=step_addr)
+            run_kwargs.update(kwargs)
 
-            elif hasattr(step, "arun"):
-                # Team, SequentialPipeline, HierarchicalTeam with async support
-                response = await step.arun(
-                    user_input=current_input, session_id=session_id, user_id=user_id
-                )
-            elif hasattr(step, "run"):
-                # Fallback to sync run for flows without arun
-                response = step.run(
-                    user_input=current_input, session_id=session_id, user_id=user_id
-                )
-            else:
-                raise ValueError(
-                    f"Step {i} ({type(step)}) is not a valid agent or flow."
-                )
+            # Polymorphic call
+            response = await step.arun(user_input=current_input, **run_kwargs)
 
             # If not last step, consume output to pass to next step
             if not is_last_step:

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/multi_agent/team.py

@@ -1,10 +1,12 @@
-from typing import List, Optional, Union, Generator, AsyncGenerator
+from typing import List, Optional, Union, Generator, AsyncGenerator, Any, Dict
+import copy
+from agentify.core.runnable import Runnable
 from agentify.core.agent import BaseAgent
 from agentify.memory.interfaces import MemoryAddress
 from agentify.multi_agent.tool_wrapper import AgentTool
 
 
-class Team:
+class Team(Runnable):
     """Orchestrates a group of agents.
 
     The Team class:
@@ -33,6 +35,7 @@ class Team:
         user_input: str,
         session_id: str = "default_session",
         user_id: str = "default_user",
+        **kwargs: Any,
     ) -> Union[str, Generator[str, None, None]]:
         """Run the team workflow.
 
@@ -48,6 +51,11 @@ class Team:
             agent_id=self.supervisor.config.name,
         )
 
+        # Clone supervisor to avoid tool pollution across runs
+        # Use shallow copy + manual tools dict copy to avoid deepcopying net clients
+        supervisor = copy.copy(self.supervisor)
+        supervisor._tools = self.supervisor._tools.copy()
+
         # 2. Register Workers as Tools (Dynamic Registration)
         # Wrap each worker in an AgentTool, bound to the supervisor's address context
         worker_tools = []
@@ -55,22 +63,20 @@ class Team:
             tool_wrapper = AgentTool(agent=worker, parent_addr=supervisor_addr)
             worker_tools.append(tool_wrapper)
 
-            # Register with supervisor
-            self.supervisor.register_tool(tool_wrapper)
+            # Register with CLONED supervisor
+            supervisor.register_tool(tool_wrapper)
 
         # 3. Run Supervisor
-        return self.supervisor.run(user_input=user_input, addr=supervisor_addr)
+        return supervisor.run(user_input=user_input, addr=supervisor_addr)
 
     async def arun(
         self,
         user_input: str,
         session_id: str = "default_session",
         user_id: str = "default_user",
+        **kwargs: Any,
     ) -> Union[str, AsyncGenerator[str, None]]:
-        """Async version of run().
-        
-        Uses the supervisor's arun() for async execution with parallel tool calls.
-        """
+        """Async version of run()."""
         # 1. Setup Supervisor Address
         supervisor_addr = MemoryAddress(
             user_id=user_id,
@@ -78,11 +84,14 @@ class Team:
             agent_id=self.supervisor.config.name,
         )
 
+        supervisor = copy.copy(self.supervisor)
+        supervisor._tools = self.supervisor._tools.copy()
+
         # 2. Register Workers as Tools
         for worker in self.workers:
             tool_wrapper = AgentTool(agent=worker, parent_addr=supervisor_addr)
-            self.supervisor.register_tool(tool_wrapper)
+            supervisor.register_tool(tool_wrapper)
 
         # 3. Run Supervisor asynchronously
-        return await self.supervisor.arun(user_input=user_input, addr=supervisor_addr)
+        return await supervisor.arun(user_input=user_input, addr=supervisor_addr)
 

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify/multi_agent/tool_wrapper.py

@@ -1,5 +1,6 @@
 from typing import Any, Dict, Optional
 import asyncio
+import hashlib
 from agentify.core.agent import BaseAgent
 from agentify.core.tool import Tool
 from agentify.memory.interfaces import MemoryAddress
@@ -245,10 +246,11 @@ class SpawnAgentTool(Tool):
         if system_prompt:
             new_config.system_prompt = system_prompt
         
-        # Create a unique address for this interaction
+        # Create a unique address for this interaction using hash of instructions
+        instr_hash = hashlib.sha256(instructions.encode("utf-8")).hexdigest()[:16]
         child_addr = MemoryAddress(
             user_id=self.parent_addr.user_id,
-            conversation_id=f"{self.parent_addr.conversation_id}_{role_name}_{instructions[:10]}",
+            conversation_id=f"{self.parent_addr.conversation_id}_{role_name}_{instr_hash}",
             agent_id=new_config.name,
         )
 
@@ -288,9 +290,10 @@ class SpawnAgentTool(Tool):
         if system_prompt:
             new_config.system_prompt = system_prompt
         
+        instr_hash = hashlib.sha256(instructions.encode("utf-8")).hexdigest()[:16]
         child_addr = MemoryAddress(
             user_id=self.parent_addr.user_id,
-            conversation_id=f"{self.parent_addr.conversation_id}_{role_name}_{instructions[:10]}",
+            conversation_id=f"{self.parent_addr.conversation_id}_{role_name}_{instr_hash}",
             agent_id=new_config.name,
         )
 

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: agentify-core
-Version: 0.3.0
+Version: 0.3.1
 Summary: Framework-agnostic AI agent library for building single and multi-agent systems
-Author-email: Fabian M <fabianmp_98@hotmail.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
@@ -24,6 +25,7 @@ License-File: LICENSE
 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

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify_core.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ agentify/core/__init__.py
 agentify/core/agent.py
 agentify/core/callbacks.py
 agentify/core/config.py
+agentify/core/runnable.py
 agentify/core/tool.py
 agentify/extensions/__init__.py
 agentify/extensions/prompts/__init__.py
@@ -47,5 +48,7 @@ agentify_core.egg-info/requires.txt
 agentify_core.egg-info/top_level.txt
 tests/test_filesystem_tools.py
 tests/test_mcp.py
+tests/test_memory_address.py
+tests/test_memory_logging.py
 tests/test_planning_tool.py
 tests/test_verify_hooks.py

{agentify_core-0.3.0 → agentify_core-0.3.1}/agentify_core.egg-info/requires.txt

@@ -1,6 +1,7 @@
 openai
 python-dotenv
 Pillow
+jsonschema>=4.0.0
 
 [all]
 redis>=4.0.0

{agentify_core-0.3.0 → agentify_core-0.3.1}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentify-core"
-version = "0.3.0"
+version = "0.3.1"
 description = "Framework-agnostic AI agent library for building single and multi-agent systems"
 readme = "README_PYPI.md"
 requires-python = ">=3.10"
 license = {text = "MIT"}
 authors = [
-    {name = "Fabian M", email = "fabianmp_98@hotmail.com"}
+    {name = "Fabian M"},
+    {email = "fabianmp_98@hotmail.com"}
 ]
 keywords = ["agentify", "agentify-core","agent", "multi-agent", "ai", "llm", "openai", "framework"]
 classifiers = [
@@ -31,6 +32,7 @@ dependencies = [
     "openai",
     "python-dotenv",
     "Pillow",
+    "jsonschema>=4.0.0",
 ]
 
 # Dependencias opcionales

{agentify_core-0.3.0 → agentify_core-0.3.1}/requirements.txt

@@ -2,6 +2,7 @@
 openai
 python-dotenv
 Pillow
+jsonschema>=4.0.0
 
 # --- Optional Extensions ---
 # Redis Storage

{agentify_core-0.3.0 → agentify_core-0.3.1}/tests/test_filesystem_tools.py

@@ -1,7 +1,7 @@
 import os
 import tempfile
 import pytest
-from agentify.tools.filesystem import ListDirTool, ReadFileTool, WriteFileTool
+from agentify.extensions.tools.filesystem import ListDirTool, ReadFileTool, WriteFileTool
 
 
 class TestFilesystemTools:
@@ -48,6 +48,19 @@ class TestFilesystemTools:
             with open(os.path.join(tmpdir, "output.txt"), "r") as f:
                 assert f.read() == "Test content"
 
+    def test_read_file_tool_truncation(self):
+        """Test ReadFileTool enforces max_bytes limit."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = os.path.join(tmpdir, "big.txt")
+            with open(test_file, "w") as f:
+                f.write("A" * 50)
+
+            tool = ReadFileTool(sandbox_dir=tmpdir)
+            result = tool._read_file("big.txt", max_bytes=10)
+
+            assert result.startswith("A" * 10)
+            assert "[Truncated to 10 bytes]" in result
+ 
     def test_sandbox_security(self):
         """Test that sandbox prevents access outside its boundaries."""
         with tempfile.TemporaryDirectory() as tmpdir:
@@ -58,5 +71,6 @@ class TestFilesystemTools:
             assert "Access denied" in result or "Error" in result
 
 
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

agentify_core-0.3.1/tests/test_memory_address.py

@@ -0,0 +1,26 @@
+import pytest
+
+from agentify.memory.interfaces import MemoryAddress, Message
+from agentify.memory.stores.sqlite_store import SQLiteStore
+
+
+def test_memory_address_encoding_roundtrip(tmp_path):
+    db_path = tmp_path / "memory.db"
+    store = SQLiteStore(str(db_path))
+
+    addr = MemoryAddress(
+        user_id="user:1",
+        conversation_id="conv=1",
+        agent_id="agent/name",
+        extras=(("chan:1", "a:b"),),
+    )
+    store.append_message(addr, Message(role="user", content="hi"))
+
+    conversations = store.list_conversations()
+    assert len(conversations) == 1
+
+    recovered = conversations[0]
+    assert recovered.user_id == addr.user_id
+    assert recovered.conversation_id == addr.conversation_id
+    assert recovered.agent_id == addr.agent_id
+    assert recovered.extras == addr.extras

agentify_core-0.3.1/tests/test_memory_logging.py

@@ -0,0 +1,58 @@
+import logging
+
+from agentify.memory.interfaces import MemoryAddress, Message
+from agentify.memory.service import MemoryService
+
+
+class InMemoryStore:
+    def __init__(self):
+        self.data = {}
+
+    def append_message(self, addr: MemoryAddress, msg: Message) -> None:
+        key = addr.key_str()
+        self.data.setdefault(key, []).append(msg)
+
+    def read_messages(self, addr: MemoryAddress, start: int = 0, end: int = -1):
+        key = addr.key_str()
+        msgs = self.data.get(key, [])
+        return msgs[start:] if end == -1 else msgs[start:end]
+
+    def replace_messages(self, addr: MemoryAddress, messages):
+        self.data[addr.key_str()] = list(messages)
+
+    def delete_conversation(self, addr: MemoryAddress) -> None:
+        self.data.pop(addr.key_str(), None)
+
+    def set_ttl(self, addr: MemoryAddress, seconds: int) -> None:
+        return None
+
+    def list_conversations(self, limit: int = 100, offset: int = 0):
+        return []
+
+
+def test_memory_service_redacts_logs(caplog):
+    store = InMemoryStore()
+    service = MemoryService(store, log_enabled=True, max_log_length=5000)
+    addr = MemoryAddress(conversation_id="conv:test")
+
+    message = {
+        "role": "user",
+        "content": {"api_key": "secret-value", "note": "ok"},
+        "metadata": {
+            "tool_calls": [
+                {
+                    "function": {
+                        "name": "do_thing",
+                        "arguments": {"token": "token123"},
+                    }
+                }
+            ]
+        },
+    }
+
+    with caplog.at_level(logging.INFO):
+        service.append_history(addr, message)
+
+    assert "secret-value" not in caplog.text
+    assert "token123" not in caplog.text
+    assert "******" in caplog.text

{agentify_core-0.3.0 → agentify_core-0.3.1}/tests/test_planning_tool.py

@@ -1,5 +1,5 @@
 import pytest
-from agentify.tools.planning import TodoTool
+from agentify.extensions.tools.planning import TodoTool
 
 
 class TestPlanningTool: