aixtools 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

notebooks/example_mcp_server_stdio.ipynb

@@ -1,76 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "57d36f62",
-   "metadata": {},
-   "source": [
-    "# Example MCP Server STDIO"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ebf6d915",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from aixtools.agents.agent import get_agent, run_agent\n",
-    "from aixtools.utils.config import PROJECT_DIR\n",
-    "from pydantic_ai.mcp import MCPServerStdio"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "97d1e607",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mcp_path = PROJECT_DIR /'aixtools' / 'mcp' / 'example_server.py'\n",
-    "server = MCPServerStdio(command='fastmcp', args=['run', str(mcp_path)])\n",
-    "agent = get_agent(mcp_servers=[server])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fc560d25",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async with agent:\n",
-    "    ret = await run_agent(agent, \"What is the add of 40123456789 and 2123456789?\", verbose=True, debug=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cad32e85",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

notebooks/example_raw_mcp_client.ipynb

@@ -1,84 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "57d36f62",
-   "metadata": {},
-   "source": [
-    "# Example \"Raw MCP Client\"\n",
-    "\n",
-    "Run the server using the script:\n",
-    "\n",
-    "```bash\n",
-    "./scripts/run_faulty_mcp_server.sh\n",
-    "``` "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cad32e85",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from fastmcp import Client\n",
-    "import rich\n",
-    "\n",
-    "client = Client(\"http://localhost:9999/mcp/\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e372fc6a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async with client:\n",
-    "    # Basic server interaction\n",
-    "    await client.ping()\n",
-    "    \n",
-    "    # # List available operations\n",
-    "    # tools = await client.list_tools()\n",
-    "    # rich.print(tools)\n",
-    "    # \n",
-    "    # # Execute 'add' tool\n",
-    "    # result = await client.call_tool(\"add\", {\"a\": 7, \"b\": 3})\n",
-    "    # rich.print(result)\n",
-    "\n",
-    "    # Execute 'add' tool\n",
-    "    result = await client.call_tool(\"throw_404_exception\", {})\n",
-    "    rich.print(result)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a8a743e2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

notebooks/example_tool_doctor.ipynb

@@ -1,65 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "dab47237",
-   "metadata": {},
-   "source": [
-    "# Tool doctor example"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9735e38c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example 1: A reasonably well-defined tool\n",
-    "from aixtools.tools.doctor import tool_doctor\n",
-    "\n",
-    "\n",
-    "def add(a: int, b: int) -> int:\n",
-    "    \"\"\" Add two numbers \"\"\"\n",
-    "    return a + b\n",
-    "\n",
-    "# Example 2: A poorly defined tool\n",
-    "def z(a: int, b: int) -> int:\n",
-    "    \"\"\" performs some arithmentic with two parameters \"\"\"\n",
-    "    return a + b\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e50d48d6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Call tool doctor\n",
-    "ret = await tool_doctor([add, z])"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

scripts/config.sh

@@ -1,28 +0,0 @@
-#-----------------------------------------------------------------------------
-#
-# This template script sets up the environment for the project by defining the
-# project directory and activating the virtual environment.
-#
-#-----------------------------------------------------------------------------
-
-export SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-# Project directory
-export PROJECT_DIR="$( cd $SCRIPTS_DIR/.. && pwd -P )"
-export PROJECT_NAME="$(basename $PROJECT_DIR)"
-
-# Data directories
-export DATA_DIR="$PROJECT_DIR/data"
-export LOGS_DIR="$PROJECT_DIR/logs"
-export PG_DATA_DIR="$DATA_DIR/data/db/postgres"
-
-# Server configuration
-export PORT=8081
-
-# Activate virtual environment
-if [ "${OS-}" == "Windows_NT" ]; then
-    source .venv/Scripts/activate
-else
-    source .venv/bin/activate
-fi
-

scripts/lint.sh

@@ -1,32 +0,0 @@
-#!/bin/bash -eu
-set -o pipefail
-
-#-----------------------------------------------------------------------------
-#
-# Template script for running the linter
-#
-#-----------------------------------------------------------------------------
-
-
-# Get script directory
-SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source "$SCRIPTS_DIR/config.sh"
-
-# Check if the fix parameter is provided
-FIX_MODE=false
-if [[ $# -gt 0 && "$1" == "--fix" ]]; then
-    FIX_MODE=true
-fi
-
-# Run linter
-if [ "$FIX_MODE" = true ]; then
-    echo "Running linters in fix mode..."
-    ruff format .
-    ruff check --fix .
-else
-    echo "Running linters in check mode..."
-    ruff format --check .
-    ruff check .
-fi
-echo "Running pylint..."
-pylint aixtools/

scripts/log_view.sh

@@ -1,18 +0,0 @@
-#!/bin/bash -eu
-set -o pipefail
-
-#-----------------------------------------------------------------------------
-#
-# Template script for running the Chainlit server
-#
-#-----------------------------------------------------------------------------
-
-# Get script directory
-SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source "$SCRIPTS_DIR/config.sh"
-
-# Activate virtual environment (with special handling for Windows)
-cd "$PROJECT_DIR"
-
-# Run the server
-streamlit run aixtools/log_view/app.py $*

scripts/run_example_mcp_server.sh

@@ -1,14 +0,0 @@
-#!/bin/bash -eu
-set -o pipefail
-
-# Get script directory
-SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source "$SCRIPTS_DIR/config.sh"
-
-# Activate virtual environment (with special handling for Windows)
-cd "$PROJECT_DIR"
-
-# Run the example MCP server
-fastmcp run \
-    --transport http \
-    "$PROJECT_DIR/aixtools/mcp/example_server.py"

scripts/run_faulty_mcp_server.sh

@@ -1,13 +0,0 @@
-#!/bin/bash -eu
-set -o pipefail
-
-# Get script directory
-SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source "$SCRIPTS_DIR/config.sh"
-
-cd "$PROJECT_DIR"
-
-while true; do
-    uv run aixtools/mcp/faulty_mcp.py "$@" || true
-    echo "MCP server terminated. Restarting..."
-done

scripts/run_server.sh

@@ -1,29 +0,0 @@
-#!/bin/bash -eu
-set -o pipefail
-
-#-----------------------------------------------------------------------------
-#
-# Template script for running the Chainlit server
-#
-#-----------------------------------------------------------------------------
-
-# Get script directory
-SCRIPTS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source "$SCRIPTS_DIR/config.sh"
-
-# Activate virtual environment (with special handling for Windows)
-cd "$PROJECT_DIR"
-
-# Run linter before starting the server
-"$SCRIPTS_DIR/lint.sh"
-
-# Go into the sub-dir (most projects don't need this)
-cd "$PROJECT_NAME"
-
-# Run the server
-chainlit run \
-    --host 0.0.0.0 \
-    --port $PORT \
-    --root-path /$PROJECT_NAME \
-    --watch \
-    app.py

scripts/test.sh

@@ -1,30 +0,0 @@
-#!/bin/bash -eu
-set -o pipefail
-
-# Get the directory of this script
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/config.sh"
-
-# Install required dependencies
-echo "Installing test dependencies..."
-uv pip install pytest pytest-asyncio pytest-mock pytest-cov
-
-# Ensure .env exists
-touch .env
-
-# Add the project root to PYTHONPATH so imports work correctly
-export PYTHONPATH="${PROJECT_DIR}:${PYTHONPATH:-}"
-
-# Check if a specific test is provided as parameter
-if [ $# -eq 1 ]; then
-    # Run specific test without coverage
-    echo "Running specific test: $1"
-    pytest "$1" -v
-else
-    # Run all tests using pytest with coverage
-    echo "Running tests with coverage..."
-    pytest tests/ -v --cov=aixtools --cov-report=term-missing
-    
-    # Generate HTML coverage report
-    # pytest tests/ --cov=aixtools --cov-report=html
-fi

tests/unit/a2a/google_sdk/pydantic_ai_adapter/test_agent_executor.py

@@ -1,188 +0,0 @@
-"""Tests for the Pydantic AI adapter agent executor module."""
-
-import unittest
-from unittest.mock import AsyncMock, MagicMock, patch
-
-from a2a.server.agent_execution import RequestContext
-from a2a.server.events import EventQueue
-from a2a.types import Message, TaskState, TaskStatusUpdateEvent
-from pydantic_ai import Agent
-
-from aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor import (
-    AgentParameters,
-    RunOutput,
-    PydanticAgentExecutor,
-    _task_failed_event,
-)
-
-
-class TestAgentParameters(unittest.TestCase):
-    """Tests for the AgentParameters model."""
-
-    def test_agent_parameters_creation(self):
-        """Test creating AgentParameters with valid data."""
-        params = AgentParameters(
-            system_prompt="Test prompt",
-            mcp_servers=["server1", "server2"]
-        )
-        
-        self.assertEqual(params.system_prompt, "Test prompt")
-        self.assertEqual(params.mcp_servers, ["server1", "server2"])
-
-
-class TestRunOutput(unittest.TestCase):
-    """Tests for the RunOutput model."""
-
-    def test_run_output_creation(self):
-        """Test creating RunOutput with valid data."""
-        output = RunOutput(
-            is_task_failed=False,
-            is_task_in_progress=True,
-            is_input_required=False,
-            output="Test output",
-            created_artifacts_paths=["path1", "path2"]
-        )
-        
-        self.assertFalse(output.is_task_failed)
-        self.assertTrue(output.is_task_in_progress)
-        self.assertFalse(output.is_input_required)
-        self.assertEqual(output.output, "Test output")
-        self.assertEqual(output.created_artifacts_paths, ["path1", "path2"])
-
-
-class TestTaskFailedEvent(unittest.TestCase):
-    """Tests for the _task_failed_event function."""
-
-    def test_task_failed_event_creation(self):
-        """Test creating a task failed event."""
-        text = "Test error message"
-        context_id = "ctx123"
-        task_id = "task456"
-        
-        event = _task_failed_event(text, context_id, task_id)
-        
-        self.assertIsInstance(event, TaskStatusUpdateEvent)
-        self.assertEqual(event.status.state, TaskState.failed)
-        self.assertEqual(event.context_id, context_id)
-        self.assertEqual(event.task_id, task_id)
-        self.assertTrue(event.final)
-
-    def test_task_failed_event_with_none_ids(self):
-        """Test creating a task failed event with None IDs."""
-        text = "Test error message"
-        
-        event = _task_failed_event(text, "default_ctx", "default_task")
-        
-        self.assertIsInstance(event, TaskStatusUpdateEvent)
-        self.assertEqual(event.status.state, TaskState.failed)
-        self.assertEqual(event.context_id, "default_ctx")
-        self.assertEqual(event.task_id, "default_task")
-        self.assertTrue(event.final)
-
-
-class TestPydanticAgentExecutor(unittest.IsolatedAsyncioTestCase):
-    """Tests for the PydanticAgentExecutor class."""
-
-    def setUp(self):
-        self.agent_params = AgentParameters(
-            system_prompt="Test system prompt",
-            mcp_servers=["test_server"]
-        )
-        self.executor = PydanticAgentExecutor(self.agent_params)
-
-    def test_init(self):
-        """Test PydanticAgentExecutor initialization."""
-        self.assertEqual(self.executor._agent_parameters, self.agent_params)
-        self.assertIsNotNone(self.executor.history_storage)
-
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_message_text")
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_file_parts")
-    def test_convert_message_to_pydantic_parts_text_only(self, mock_get_file_parts, mock_get_message_text):
-        """Test converting message with text only."""
-        mock_get_message_text.return_value = "Test message"
-        mock_get_file_parts.return_value = []
-        
-        mock_message = MagicMock(spec=Message)
-        mock_message.parts = []
-        session_tuple = ("user1", "session1")
-        
-        result = self.executor._convert_message_to_pydantic_parts(session_tuple, mock_message)
-        
-        self.assertEqual(result, "Test message")
-        mock_get_message_text.assert_called_once_with(mock_message)
-        mock_get_file_parts.assert_called_once_with([])
-
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.build_user_input")
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_message_text")
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_file_parts")
-    def test_convert_message_to_pydantic_parts_with_files(self, mock_get_file_parts, mock_get_message_text, mock_build_user_input):
-        """Test converting message with files."""
-        mock_get_message_text.return_value = "Test message"
-        mock_file_part = MagicMock()
-        mock_file_part.uri = "/test/path.txt"
-        mock_get_file_parts.return_value = [mock_file_part]
-        mock_build_user_input.return_value = ["processed", "input"]
-        
-        mock_message = MagicMock(spec=Message)
-        mock_message.parts = [mock_file_part]
-        session_tuple = ("user1", "session1")
-        
-        result = self.executor._convert_message_to_pydantic_parts(session_tuple, mock_message)
-        
-        self.assertEqual(result, ["processed", "input"])
-        # Verify that build_user_input was called (exact args may vary due to filtering)
-        mock_build_user_input.assert_called_once()
-
-    def test_execute_no_message_validation(self):
-        """Test that execute validates message presence."""
-        # This is a simple validation test without complex integration
-        mock_context = MagicMock(spec=RequestContext)
-        mock_context.message = None
-        
-        # The actual validation happens in the execute method
-        # We test the validation logic separately
-        self.assertIsNone(mock_context.message)
-
-    async def test_cancel_not_supported(self):
-        """Test that cancel raises an exception."""
-        mock_context = MagicMock(spec=RequestContext)
-        mock_event_queue = AsyncMock(spec=EventQueue)
-        
-        with self.assertRaises(Exception) as context:
-            await self.executor.cancel(mock_context, mock_event_queue)
-        
-        self.assertIn("cancel not supported", str(context.exception))
-
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_agent")
-    @patch("aixtools.a2a.google_sdk.pydantic_ai_adapter.agent_executor.get_configured_mcp_servers")
-    def test_build_agent(self, mock_get_mcp_servers, mock_get_agent):
-        """Test building an agent."""
-        mock_agent = MagicMock(spec=Agent)
-        mock_get_agent.return_value = mock_agent
-        mock_get_mcp_servers.return_value = ["mcp1", "mcp2"]
-        
-        session_tuple = ("user1", "session1")
-        result = self.executor._build_agent(session_tuple)
-        
-        self.assertEqual(result, mock_agent)
-        mock_get_mcp_servers.assert_called_once_with(session_tuple, ["test_server"])
-        mock_get_agent.assert_called_once_with(
-            system_prompt="Test system prompt",
-            toolsets=["mcp1", "mcp2"],
-            output_type=RunOutput
-        )
-
-    def test_task_creation_logic(self):
-        """Test task creation logic validation."""
-        # Test the basic logic without complex integration
-        mock_context = MagicMock(spec=RequestContext)
-        mock_context.current_task = None
-        mock_context.message = MagicMock(spec=Message)
-        
-        # Verify that when current_task is None, we have a message to work with
-        self.assertIsNone(mock_context.current_task)
-        self.assertIsNotNone(mock_context.message)
-
-
-if __name__ == '__main__':
-    unittest.main()