aisolate-agent 0.1.0__tar.gz

aisolate_agent-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: aisolate-agent
+Version: 0.1.0
+Summary: AI Agent with intelligent planning and reasoning
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai-harmony>=0.0.8
+Requires-Dist: openai>=1.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: tiktoken>=0.5.0
+Requires-Dist: structlog>=23.2.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: opentelemetry-instrumentation>=0.41b0
+Requires-Dist: opentelemetry-exporter-otlp>=1.20.0
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.41b0
+Requires-Dist: opentelemetry-instrumentation-aiohttp-client>=0.41b0
+Requires-Dist: langfuse>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: wikipedia-api>=0.6.0
+
+# aisolate-agent
+
+AI Agent with intelligent planning and reasoning
+
+## Local Installation
+
+```bash
+pip install path/to/aisolate_agent-0.1.0-py3-none-any.whl
+```
+
+## Usage
+
+```python
+# Import the main module
+import aisolate.agent
+
+# Use the package...
+```
+
+## Requirements
+
+- Python 3.10+
+
+## License
+
+Apache License 2.0

aisolate_agent-0.1.0/README.md

@@ -0,0 +1,26 @@
+# aisolate-agent
+
+AI Agent with intelligent planning and reasoning
+
+## Local Installation
+
+```bash
+pip install path/to/aisolate_agent-0.1.0-py3-none-any.whl
+```
+
+## Usage
+
+```python
+# Import the main module
+import aisolate.agent
+
+# Use the package...
+```
+
+## Requirements
+
+- Python 3.10+
+
+## License
+
+Apache License 2.0

aisolate_agent-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aisolate-agent"
+version = "0.1.0"
+description = "AI Agent with intelligent planning and reasoning"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+
+dependencies = [
+    "openai-harmony>=0.0.8",
+    "openai>=1.0.0",
+    "jinja2>=3.1.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+    "aiofiles>=23.0.0",
+    "tiktoken>=0.5.0",
+    "structlog>=23.2.0",
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-instrumentation>=0.41b0",
+    "opentelemetry-exporter-otlp>=1.20.0",
+    "opentelemetry-instrumentation-httpx>=0.41b0",
+    "opentelemetry-instrumentation-aiohttp-client>=0.41b0",
+    "langfuse>=2.0.0",
+    "rich>=13.0.0",
+    "wikipedia-api>=0.6.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["aisolate*"]
+
+[project.scripts]
+aisolate-agent = "aisolate.agent.main:main"

aisolate_agent-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aisolate_agent-0.1.0/src/aisolate/agent/agent.py

@@ -0,0 +1,516 @@
+"""Main Agent class - public API for the three-tier tool architecture."""
+
+from typing import Optional, Dict, Any, List, Iterable, TYPE_CHECKING
+import time
+import traceback
+
+from .config.agent_settings import AgentSettings
+from .core.context import AgentContext
+from .core.protocols import LLMStrategy, MemoryStrategy
+from .core.snapshot import AgentSnapshot
+from .core.events import (
+    AgentStartedEvent,
+    TurnCompletedEvent,
+    AgentFinishedEvent,
+    AgentErrorEvent,
+)
+from openai_harmony import Author, Message, Role, TextContent
+from .states.planning import PlanningState
+from .utils import get_logger, setup_logging
+from .logging import LoggingConfig
+
+from .tools.platform.subagent import SubAgentTool
+from .tools.platform.python_executor import PythonExecutorTool
+from .tools.actions.final_answer import FinalAnswerAction
+from .tools.actions.base import validate_action
+
+from aisolate.client.sandbox import Sandbox
+
+from .tools.models import FinalAnswerResult
+
+logger = get_logger("aisolate.agent")
+
+
+class Agent:
+    """Main agent class that orchestrates the three-tier tool architecture.
+
+    This class provides the public API for creating and running agents with
+    different strategies for LLM interaction, memory and tool execution.
+
+    Example usage:
+        ```python
+        # Create agent with pre-configured strategies
+        harmony_llm = HarmonyLLMStrategy(base_url="https://api.harmony.ai/v1")
+        in_memory = InMemoryStrategy()
+
+        async with Sandbox() as sandbox:
+            agent = Agent(
+                llm_strategy=harmony_llm,
+                memory_strategy=in_memory,
+                sandbox=sandbox,
+                settings=AgentSettings(max_turns=20),
+                actions=[WebSearchAction()]
+            )
+
+            result = await agent.run("What is the weather in San Francisco?")
+            print(result)
+        ```
+    """
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        llm_strategy: LLMStrategy,
+        memory_strategy: MemoryStrategy,
+        sandbox: Sandbox,
+        settings: Optional[AgentSettings] = None,
+        managed_agents: Optional[List["Agent"]] = None,
+        builtin_tools: Optional[Iterable[Any]] = None,
+        function_tools: Optional[Iterable[Any]] = None,
+        actions: Optional[List[Any]] = None,
+    ):
+        """Initialize the Agent with configured strategies.
+
+        Args:
+            llm_strategy: Pre-configured LLM strategy implementation
+            memory_strategy: Pre-configured memory strategy implementation
+            sandbox: Active sandbox instance for code execution
+            settings: Agent-specific configuration settings
+            builtin_tools: Optional list of builtin platform tools
+            function_tools: Optional list of function tools
+            actions: List of action instances
+        """
+        self.name = name
+        self.description = description
+        self.llm_strategy = llm_strategy
+        self.memory_strategy = memory_strategy
+        self.sandbox = sandbox
+        self.settings = settings or AgentSettings()
+
+        # --- Defaults & override merging ---
+        def _default_builtin() -> list[Any]:
+            python_tool = PythonExecutorTool()
+            # Apply strategy-specific tool name override for reserved names
+            python_tool.name = self.llm_strategy.get_tool_name("python")
+            return [python_tool]
+
+        if managed_agents is None:
+            self.sub_agent_tools = {}
+        else:
+            self.sub_agent_tools = {}
+            for agent in managed_agents:
+                # Pass namespace config from parent's LLM strategy (Solution 1)
+                sa = SubAgentTool(
+                    agent=agent,
+                    namespace_config=self.llm_strategy.namespace_config,
+                )
+                self.sub_agent_tools[sa.name] = sa
+
+        if builtin_tools is None:
+            self.builtin_tools = _default_builtin()
+        else:
+            # Merge: user overrides by name and apply strategy-specific name overrides
+            base = {t.name: t for t in _default_builtin()}
+            for t in builtin_tools:
+                # Apply strategy-specific name override
+                t.name = self.llm_strategy.get_tool_name(t.name)
+                base[t.name] = t
+            self.builtin_tools = list(base.values())
+
+        self.function_tools = list(function_tools or [])
+
+        # Actions: ensure final_answer exists; convert list to dict using action.name
+        base_actions: Dict[str, Any] = {"final_answer": FinalAnswerAction()}
+
+        if actions:
+            # Convert list of actions to dict using action.name as key
+            for action in actions:
+                if hasattr(action, "name") and action.name:
+                    base_actions[action.name] = action
+                else:
+                    raise ValueError(
+                        f"Action {action.__class__.__name__} must have a valid 'name' attribute"
+                    )
+
+        # Validate all actions during agent initialization
+        validated_actions = {}
+        for name, action in base_actions.items():
+            try:
+                validate_action(action)
+                logger.info("Validated action", action_name=name)
+                validated_actions[name] = action
+            except Exception as e:
+                logger.error("Action validation failed", action_name=name, error=str(e))
+                raise ValueError(f"Invalid action '{name}': {e}") from e
+
+        self.actions = validated_actions
+
+    async def run(self, task: str) -> "FinalAnswerResult":
+        """Run the agent on a single task and return the final answer.
+
+        This is a convenience wrapper around run_streaming() that extracts
+        just the final result. Creates a new conversation with a generated UUID.
+
+        Args:
+            task: The task description for the agent to accomplish
+
+        Returns:
+            FinalAnswerResult containing answer text and optional metadata (sources, confidence)
+
+        Raises:
+            RuntimeError: If agent is already running or no final answer provided
+            ValueError: If task is empty
+        """
+        import uuid
+
+        final_answer: Optional[FinalAnswerResult] = None
+
+        # Generate new conversation_id for this execution
+        conversation_id = str(uuid.uuid4())
+
+        async for update in self.run_streaming(task, conversation_id):
+            if hasattr(update, "type") and update.type == "agent_finished":
+                final_answer = getattr(update, "final_answer", None)
+                if final_answer is not None:
+                    return final_answer
+            elif hasattr(update, "type") and update.type == "agent_error":
+                # Always raise exceptions in the synchronous run() method
+                error_msg = getattr(update, "error", "Unknown error")
+                raise RuntimeError(f"Agent execution failed: {error_msg}")
+
+        # If we get here, no final answer was provided
+        raise RuntimeError("Agent completed without providing a final answer")
+
+    async def run_streaming(self, task: str, conversation_id: str):
+        """Run the agent with streaming updates.
+
+        Creates a fresh context-bound sandbox for each execution.
+
+        Args:
+            task: The task description for the agent to accomplish
+            conversation_id: Conversation UUID (required)
+                - New conversation: caller generates new UUID
+                - Existing conversation: caller provides existing UUID
+
+        Yields:
+            Dict updates about agent state, tool calls, and progress
+        """
+        # Add structured logging context
+        bound_logger = logger.bind(
+            task=task,
+            agent_id=id(self),
+            llm_strategy=type(self.llm_strategy).__name__,
+            memory_strategy=type(self.memory_strategy).__name__,
+            conversation_id=conversation_id,
+        )
+
+        bound_logger.info("Starting agent execution")
+
+        try:
+            # Use new telemetry system for tracing
+            from .telemetry import get_tracer
+
+            tracer = get_tracer()
+
+            with tracer.span("agent.session") as session_span:  # type: ignore
+                session_span.set_attribute("agent.task", task)
+                session_span.set_attribute(
+                    "agent.llm_strategy", type(self.llm_strategy).__name__
+                )
+                session_span.set_attribute(
+                    "agent.memory_strategy", type(self.memory_strategy).__name__
+                )
+                session_span.set_attribute("agent.max_turns", self.settings.max_turns)
+
+                # Create fresh context-bound sandbox for this execution
+                sandbox_ctx = await self.sandbox.acreate_context_bound_sandbox()
+
+                # Create fresh AgentContext for this execution
+                context = AgentContext(
+                    agent_name=self.name,
+                    task=task,
+                    llm=self.llm_strategy,
+                    memory=self.memory_strategy,
+                    sandbox=sandbox_ctx,
+                    max_turns=self.settings.max_turns,
+                    conversation_id=conversation_id,
+                    sub_agent_tools=self.sub_agent_tools,
+                    actions=self.actions,
+                    builtin_tools=self.builtin_tools,
+                    function_tools=self.function_tools,
+                    parent_context=None,  # Top-level agent
+                )
+
+                # RESTORATION LOGIC - Load and apply snapshot if it exists
+                snapshot = await context.memory.load_latest_snapshot(conversation_id)
+                if snapshot:
+                    self._restore_context_from_snapshot(context, snapshot)
+                    bound_logger.info(
+                        "Restored from snapshot",
+                        turn=snapshot.turn,
+                        messages_count=len(snapshot.conversation_history),
+                    )
+                else:
+                    bound_logger.debug("No snapshot found, starting fresh")
+
+                # Execute with prepared context
+                async for result in self._execute_with_context(
+                    context, bound_logger, tracer
+                ):
+                    yield result
+        except Exception as e:
+            import traceback
+
+            # Log with full stack trace
+            bound_logger.error(
+                "Agent execution failed (outer catch)",
+                error=str(e),
+                exception=type(e).__name__,
+                traceback=traceback.format_exc(),
+            )
+
+            # Also use structured exception logging
+            bound_logger.log_exception(e, "agent_execution_outer")
+
+            yield AgentErrorEvent(
+                error=str(e),
+                exception_type=type(e).__name__,
+                traceback=(
+                    traceback.format_exc() if self.settings.debug_mode else None
+                ),
+                turn=0,
+            )
+            if self.settings.debug_mode:
+                raise
+
+    def _restore_context_from_snapshot(
+        self, context: AgentContext, snapshot: "AgentSnapshot"
+    ) -> None:
+        """Restore context from snapshot with smart state handling.
+
+        - If snapshot.finished = True: Reset to Planning (new task on completed conversation)
+        - If snapshot.finished = False: Preserve turn for resumption
+
+        Args:
+            context: Fresh context to restore into
+            snapshot: Snapshot with saved state
+        """
+        from openai_harmony import Message
+        from .states.planning import PlanningState
+
+        # Restore conversation history (using from_dict because messages are serialized with to_dict())
+        messages = [
+            Message.from_dict(msg_data) for msg_data in snapshot.conversation_history
+        ]
+        context.set_conversation_history(messages)
+
+        # Restore execution state
+        context.execution.turn = snapshot.turn
+
+        # Always reset execution.finished to allow continuation
+        context.execution.finished = False
+
+        # Smart state restoration: reset to Planning if conversation was completed
+        if snapshot.finished:
+            # Completed conversation: start fresh with new planning
+            context.transition_to(PlanningState())
+            logger.info(
+                "Restored completed conversation, reset to Planning",
+                turn=snapshot.turn,
+                conversation_id=snapshot.conversation_id,
+            )
+
+        # Restore final answer if present (for context/display)
+        # if snapshot.final_answer:
+        #     from .tools.models import FinalAnswerResult
+
+        #     context._final_answer = FinalAnswerResult(**snapshot.final_answer)
+
+        logger.debug(
+            "Context restored from snapshot",
+            turn=snapshot.turn,
+            messages_count=len(messages),
+            had_final_answer=bool(snapshot.final_answer),
+        )
+
+    async def _execute_with_context(self, context: AgentContext, bound_logger, tracer):
+        """Execute agent with given context.
+
+        Context is assumed to be ready (fresh or restored).
+        NO restoration logic here - that happens in run_streaming().
+
+        Args:
+            context: Fresh AgentContext with isolated sandbox (possibly restored)
+            bound_logger: Logger with bound context
+            tracer: Telemetry tracer
+        """
+        start_time = time.time()
+        try:
+            # Initialize remote python executor with actions
+            await context.remote_python_executor.send_actions(self.actions)
+
+            # Initialize conversation history with LLM strategy (only if not restored)
+            # if not context.get_conversation_messages():
+            initial_messages = self.llm_strategy.prepare_initial_history(context)
+            context.initialize_conversation(initial_messages)
+            # else:
+            #     context.initialize_conversation(
+            #         [Message.from_role_and_content(Role.USER, context.task)]
+            #     )
+
+            # Set initial state (only if not restored)
+            if context.execution.current_state is None:
+                context.transition_to(PlanningState())
+
+            yield AgentStartedEvent(
+                task=context.task,
+                turn=context.turn,
+                max_turns=self.settings.max_turns,
+                agent_name=self.name,
+                conversation_id=context.conversation_id,
+            )
+
+            # Execute agent turns until completion
+            while not context.is_finished:
+                # Create tracing span for individual turn (always - no conditional logic)
+                with tracer.span(f"agent.turn.{context.turn}") as turn_span:  # type: ignore
+                    turn_span.set_attribute("agent.turn", context.turn)
+                    turn_span.set_attribute(
+                        "agent.state", type(context._state).__name__
+                    )
+                    turn_span.set_attribute("agent.task", context.task)
+
+                    turn_result = await context.execute_turn()
+
+                    # Create TurnCompletedEvent with runtime metadata
+                    turn_event = TurnCompletedEvent(
+                        turn=context.turn,
+                        state=turn_result.state,
+                        is_finished=context.is_finished,
+                        final_answer=context.final_answer,
+                        state_metadata=turn_result.state_metadata,
+                    )
+
+                    # Persist snapshot if conversation_id exists
+                    if context.conversation_id:
+                        snapshot = context.create_snapshot()
+                        snapshot.add_event(
+                            turn_event
+                        )  # Store event with runtime metadata
+                        await context.memory.save_snapshot(snapshot)
+
+                    turn_span.set_attribute("turn.completed", True)
+                    turn_span.set_attribute(
+                        "turn.final_answer_provided",
+                        bool(context.final_answer),
+                    )
+                    turn_span.set_status("OK")
+
+                # Yield event for streaming
+                yield turn_event
+
+                if context.turn >= self.settings.max_turns:
+                    bound_logger.warning(
+                        "Reached max turns", max_turns=self.settings.max_turns
+                    )
+                    break
+
+            # Log completion with proper FinalAnswerResult handling
+            if context.final_answer:
+                bound_logger.info(
+                    "Agent execution completed",
+                    total_turns=context.turn,
+                    final_answer_length=len(context.final_answer.answer),
+                    has_sources=context.final_answer.sources is not None,
+                    has_confidence=context.final_answer.confidence is not None,
+                )
+            else:
+                bound_logger.info(
+                    "Agent execution completed",
+                    total_turns=context.turn,
+                    final_answer=None,
+                )
+
+            yield AgentFinishedEvent(
+                final_answer=context.final_answer,
+                total_turns=context.turn,
+                execution_time=time.time() - start_time,
+            )
+
+        except Exception as e:
+            import traceback
+
+            # Log with full stack trace
+            bound_logger.error(
+                "Agent execution failed",
+                error=str(e),
+                exception=type(e).__name__,
+                traceback=traceback.format_exc(),
+            )
+
+            # Also log the exception for structured logging
+            bound_logger.log_exception(e, "agent_execution")
+            yield AgentErrorEvent(
+                error=str(e),
+                turn=context.turn if context else 0,
+                exception_type=type(e).__name__,
+                traceback=traceback.format_exc() if self.settings.debug_mode else None,
+            )
+            if self.settings.debug_mode:
+                raise
+
+    def get_conversation_history(self) -> List[Any]:
+        """Get the current conversation history.
+
+        Note: This method is deprecated as Agent no longer maintains instance state.
+        Context is created fresh for each execution.
+
+        Returns:
+            Empty list (no persistent context)
+        """
+        return []
+
+    def get_memory(self) -> List[Dict[str, Any]]:
+        """Get the agent's long-term memory.
+
+        Note: This method is deprecated as Agent no longer maintains instance state.
+        Context is created fresh for each execution.
+
+        Returns:
+            Empty list (no persistent context)
+        """
+        return []
+
+    def is_running(self) -> bool:
+        """Check if the agent is currently running.
+
+        Note: This method is deprecated as Agent no longer tracks running state.
+        Each execution creates its own context.
+
+        Returns:
+            False (no persistent running state)
+        """
+        return False
+
+    def get_current_state(self) -> Optional[str]:
+        """Get the name of the current agent state.
+
+        Note: This method is deprecated as Agent no longer maintains instance state.
+        Context is created fresh for each execution.
+
+        Returns:
+            None (no persistent context)
+        """
+        return None
+
+    def get_turn_count(self) -> int:
+        """Get the current turn count.
+
+        Note: This method is deprecated as Agent no longer maintains instance state.
+        Context is created fresh for each execution.
+
+        Returns:
+            0 (no persistent context)
+        """
+        return 0

aisolate_agent-0.1.0/src/aisolate/agent/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration module for agent settings."""
+
+from .agent_settings import AgentSettings
+
+__all__ = ["AgentSettings"]

aisolate_agent-0.1.0/src/aisolate/agent/config/agent_settings.py

@@ -0,0 +1,39 @@
+"""Agent configuration settings."""
+
+from typing import Dict, Any, Optional
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import Field
+
+
+class AgentSettings(BaseSettings):
+    """Core agent-specific configuration only.
+
+    This class focuses solely on agent behaviors rather than strategy configuration.
+    Strategies are configured directly when instantiated.
+    """
+
+    max_turns: int = Field(
+        default=50, description="Maximum number of execution turns before agent stops"
+    )
+    reflection_turns: int = Field(
+        default=5, description="Maximum number of execution turns before agent reflects"
+    )
+    enable_error_recovery: bool = Field(
+        default=True, description="Whether to enable automatic error recovery"
+    )
+
+    max_recovery_attempts: int = Field(
+        default=3,
+        description="Maximum number of recovery attempts for failed operations",
+    )
+
+    conversation_history_max_length: Optional[int] = Field(
+        default=None,
+        description="Maximum number of messages to keep in conversation history",
+    )
+
+    debug_mode: bool = Field(
+        default=False, description="Enable debug logging and additional validation"
+    )
+
+    model_config = SettingsConfigDict(env_prefix="AGENT_", case_sensitive=False)