pygeai-orchestration 0.1.0b5__tar.gz → 0.1.0b7__tar.gz

pygeai_orchestration-0.1.0b7/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Changelog
+
+All notable changes to PyGEAI-Orchestration will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial project structure and configuration
+- Core base classes for agents, orchestrators, and patterns
+- CLI framework with `geai-orch` command
+- Reflection pattern for iterative improvement
+- Tool Use pattern for function calling
+- ReAct pattern for reasoning and acting
+- Planning pattern for multi-step execution
+- Multi-Agent pattern for collaborative workflows
+- Comprehensive test suite with unit and integration tests
+- Documentation and examples for all patterns
+- GitHub Actions CI/CD workflows
+- 9 working code snippets demonstrating all patterns:
+  - `reflection_explanation.py` - Iterative explanation improvement
+  - `reflection_code_review.py` - Code review with self-critique
+  - `react_research.py` - Structured research tasks
+  - `react_problem_solving.py` - Step-by-step problem solving
+  - `planning_project.py` - Project planning and breakdown
+  - `planning_analysis.py` - Data analysis planning
+  - `tool_use_calculator.py` - Mathematical operations with tools
+  - `tool_use_data_processing.py` - Data validation and transformation
+  - `multi_agent_collaboration.py` - Collaborative multi-agent workflow
+
+### Changed
+- **BREAKING**: Refactored entire import system to use absolute imports only
+  - All imports now use full module paths: `from pygeai_orchestration.core.base import ...`
+  - Removed all relative imports (`.module` style)
+- **BREAKING**: Removed `get_logger()` and `OrchestrationLogger` from public API
+  - All modules now use standard `logging.getLogger("pygeai_orchestration")`
+  - Logging disabled by default with `NullHandler` (follows PyGEAI pattern)
+  - Users can enable logging by configuring the `"pygeai_orchestration"` logger
+- **BREAKING**: Renamed all snippet files from `*_snippet.py` to `<pattern>_<topic>.py` format
+  - More descriptive naming that indicates pattern and use case
+  - Example: `reflection_snippet.py` → `reflection_explanation.py`
+- Updated `GEAIAgent` to use actual PyGEAI Session and ChatManager APIs
+  - Proper integration with PyGEAI chat completion
+  - Correct credential loading from `~/.geai/credentials`
+  - Support for provider-prefixed model names (e.g., `openai/gpt-4o-mini`)
+- Tool system improvements:
+  - `BaseTool` subclasses must implement `validate_parameters()` method
+  - `ToolConfig` uses `parameters_schema` field (not `parameters`)
+  - Clear ToolCategory enum values: SEARCH, COMPUTATION, DATA_ACCESS, COMMUNICATION, CUSTOM
+- All pattern implementations updated to use absolute imports and standard logging
+
+### Fixed
+- PyGEAI integration now uses correct Session and ChatManager APIs
+- Removed incorrect assumptions about `Session.agents` and `Session.chats` attributes
+- Fixed message formatting to use proper PyGEAI `ChatMessageList` and `ChatMessage` models
+- Fixed credential loading to delegate to PyGEAI's configuration system
+- Corrected model naming to include provider prefix as required by PyGEAI
+
+### Removed
+- **BREAKING**: Removed PyGEAI availability checks
+  - PyGEAI is now a required dependency
+  - No fallback or mock implementations
+- Removed `get_logger()` utility function from `pygeai_orchestration.core.utils`
+- Removed `OrchestrationLogger` singleton class
+- Removed all relative import statements across the codebase
+
+## [0.1.0b1] - 2026-02-05
+
+### Added
+- Initial beta release of PyGEAI-Orchestration
+- Foundation for agentic AI orchestration patterns
+- Integration with PyGEAI SDK
+- Basic project structure and tooling

{pygeai_orchestration-0.1.0b5/pygeai_orchestration.egg-info → pygeai_orchestration-0.1.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai-orchestration
-Version: 0.1.0b5
+Version: 0.1.0b7
 Summary: Agentic AI orchestration patterns built on Globant Enterprise AI
 Author-email: Globant <geai-sdk@globant.com>
 Keywords: geai,pygeai,orchestration,agents,ai,multi-agent,autogen,crewai
@@ -88,27 +88,37 @@ import asyncio
 from pygeai_orchestration import (
     GEAIAgent,
     AgentConfig,
+    PatternConfig,
+    PatternType,
     ReflectionPattern
 )
 
 async def main():
-    # Create an agent
-    config = AgentConfig(
+    # Create agent configuration
+    agent_config = AgentConfig(
         name="my-agent",
-        model="gpt-4",
+        model="openai/gpt-4o-mini",
         temperature=0.7
     )
-    agent = GEAIAgent(config)
+    agent = GEAIAgent(config=agent_config)
+    
+    # Create pattern configuration
+    pattern_config = PatternConfig(
+        name="reflection-example",
+        pattern_type=PatternType.REFLECTION,
+        max_iterations=3
+    )
     
     # Create and execute pattern
-    pattern = ReflectionPattern(agent=agent)
-    result = await pattern.execute("Improve this text: Hello world")
+    pattern = ReflectionPattern(agent=agent, config=pattern_config)
+    result = await pattern.execute("Explain quantum computing in simple terms")
     
     print(f"Success: {result.success}")
-    print(f"Result: {result.result}")
     print(f"Iterations: {result.iterations}")
+    print(f"Result: {result.result[:200]}...")  # First 200 chars
 
-asyncio.run(main())
+if __name__ == "__main__":
+    asyncio.run(main())
 ```
 
 ## Configuration
@@ -137,10 +147,24 @@ See [PyGEAI Configuration](https://docs.globant.ai/en/wiki?1149,Getting+started+
 Enables agents to self-critique and iteratively improve their outputs.
 
 ```python
-from pygeai_orchestration.patterns.reflection import ReflectionAgent
+from pygeai_orchestration import GEAIAgent, AgentConfig, PatternConfig, PatternType, ReflectionPattern
+
+agent = GEAIAgent(config=AgentConfig(
+    name="reflector",
+    model="openai/gpt-4o-mini",
+    temperature=0.7
+))
+
+pattern = ReflectionPattern(
+    agent=agent,
+    config=PatternConfig(
+        name="reflection",
+        pattern_type=PatternType.REFLECTION,
+        max_iterations=3
+    )
+)
 
-agent = ReflectionAgent(session=session, agent_id="critic-agent")
-result = agent.reflect_and_improve("Initial output", iterations=3)
+result = await pattern.execute("Explain quantum computing in simple terms")
 ```
 
 **Use Cases:**
@@ -148,30 +172,28 @@ result = agent.reflect_and_improve("Initial output", iterations=3)
 - Code review and refinement
 - Self-correcting responses
 
-### 2. Tool Use Pattern
-Integrates function calling and tool execution into agent workflows.
-
-```python
-from pygeai_orchestration.patterns.tool_use import ToolUseAgent
-
-agent = ToolUseAgent(session=session)
-agent.register_tool("search", search_function)
-result = agent.execute("Search for information about AI")
-```
-
-**Use Cases:**
-- API integration
-- External data retrieval
-- Action execution
-
-### 3. ReAct Pattern
+### 2. ReAct Pattern
 Implements the Reasoning + Acting loop for step-by-step problem solving.
 
 ```python
-from pygeai_orchestration.patterns.react import ReActAgent
+from pygeai_orchestration import GEAIAgent, AgentConfig, PatternConfig, PatternType, ReActPattern
+
+agent = GEAIAgent(config=AgentConfig(
+    name="reasoner",
+    model="openai/gpt-4o-mini",
+    temperature=0.7
+))
+
+pattern = ReActPattern(
+    agent=agent,
+    config=PatternConfig(
+        name="react",
+        pattern_type=PatternType.REACT,
+        max_iterations=5
+    )
+)
 
-agent = ReActAgent(session=session, agent_id="reasoning-agent")
-result = agent.solve("Complex multi-step problem")
+result = await pattern.execute("Research and summarize renewable energy benefits")
 ```
 
 **Use Cases:**
@@ -179,15 +201,28 @@ result = agent.solve("Complex multi-step problem")
 - Research tasks
 - Multi-step workflows
 
-### 4. Planning Pattern
+### 3. Planning Pattern
 Creates and executes multi-step plans with adaptive execution.
 
 ```python
-from pygeai_orchestration.patterns.planning import PlanningAgent
+from pygeai_orchestration import GEAIAgent, AgentConfig, PatternConfig, PatternType, PlanningPattern
+
+agent = GEAIAgent(config=AgentConfig(
+    name="planner",
+    model="openai/gpt-4o-mini",
+    temperature=0.5
+))
+
+pattern = PlanningPattern(
+    agent=agent,
+    config=PatternConfig(
+        name="planning",
+        pattern_type=PatternType.PLANNING,
+        max_iterations=1
+    )
+)
 
-agent = PlanningAgent(session=session, planner_id="planner")
-plan = agent.create_plan("Build a web application")
-result = agent.execute_plan(plan)
+result = await pattern.execute("Create a project plan for building a REST API")
 ```
 
 **Use Cases:**
@@ -195,16 +230,92 @@ result = agent.execute_plan(plan)
 - Task decomposition
 - Workflow automation
 
+### 4. Tool Use Pattern
+Integrates function calling and tool execution into agent workflows.
+
+```python
+from pygeai_orchestration import (
+    GEAIAgent, AgentConfig, PatternConfig, PatternType,
+    ToolUsePattern, BaseTool, ToolConfig, ToolResult, ToolCategory
+)
+
+class CalculatorTool(BaseTool):
+    def __init__(self):
+        super().__init__(ToolConfig(
+            name="calculator",
+            description="Performs calculations",
+            category=ToolCategory.COMPUTATION,
+            parameters_schema={"operation": "string", "values": "list"}
+        ))
+    
+    def validate_parameters(self, parameters):
+        return "operation" in parameters and "values" in parameters
+    
+    async def execute(self, operation, values, **kwargs):
+        if operation == "average":
+            result = sum(values) / len(values)
+            return ToolResult(success=True, result=result)
+        return ToolResult(success=False, error="Unknown operation")
+
+agent = GEAIAgent(config=AgentConfig(name="calculator", model="openai/gpt-4o-mini"))
+pattern = ToolUsePattern(
+    agent=agent,
+    config=PatternConfig(name="tools", pattern_type=PatternType.TOOL_USE),
+    tools=[CalculatorTool()]
+)
+
+result = await pattern.execute("Calculate average of: 10, 20, 30")
+```
+
+**Use Cases:**
+- API integration
+- External data retrieval
+- Action execution
+
 ### 5. Multi-Agent Pattern
 Coordinates multiple agents working collaboratively on complex tasks.
 
 ```python
-from pygeai_orchestration.patterns.multi_agent import MultiAgentCoordinator
+from pygeai_orchestration import (
+    GEAIAgent, AgentConfig, PatternConfig, PatternType, MultiAgentPattern, AgentRole
+)
+
+# Create specialized agents
+researcher = GEAIAgent(config=AgentConfig(
+    name="researcher",
+    model="openai/gpt-4o-mini",
+    system_prompt="You are a research specialist."
+))
+
+writer = GEAIAgent(config=AgentConfig(
+    name="writer",
+    model="openai/gpt-4o-mini",
+    system_prompt="You are a technical writer."
+))
+
+coordinator = GEAIAgent(config=AgentConfig(
+    name="coordinator",
+    model="openai/gpt-4o-mini",
+    system_prompt="You coordinate tasks and synthesize results."
+))
+
+# Create agent roles
+agent_roles = [
+    AgentRole(name="researcher", agent=researcher, role_description="Researches topics"),
+    AgentRole(name="writer", agent=writer, role_description="Writes reports")
+]
+
+# Create multi-agent pattern
+pattern = MultiAgentPattern(
+    agents=agent_roles,
+    coordinator_agent=coordinator,
+    config=PatternConfig(
+        name="collaboration",
+        pattern_type=PatternType.MULTI_AGENT
+    )
+)
 
-coordinator = MultiAgentCoordinator(session=session)
-coordinator.add_agent("researcher", researcher_agent)
-coordinator.add_agent("writer", writer_agent)
-result = coordinator.execute("Create research report")
+result = await pattern.execute("Create a report on AI in healthcare")
 ```
 
 **Use Cases:**
@@ -217,14 +328,13 @@ result = coordinator.execute("Create research report")
 - [Getting Started Guide](docs/getting-started.md)
 - [Pattern Documentation](docs/patterns/)
 - [API Reference](docs/api-reference/)
-- [Examples](snippets/)
+- [Code Snippets](snippets/)
 
 ## Development
 
 ### Setup Development Environment
 
 ```bash
-git clone https://docs.globant.ai/en/wiki?1149,Getting+started+with+PyGEAI-orchestration.git
 cd pygeai-orchestration
 python -m venv venv
 source venv/bin/activate  # On Windows: venv\Scripts\activate
@@ -247,15 +357,35 @@ python testing.py --coverage
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development guidelines.
 
-## Examples
+## Code Snippets
+
+Check the [snippets/](snippets/) directory for working code examples:
 
-Check the [snippets/](snippets/) directory for working examples of each pattern:
+### Reflection Pattern
+- [reflection_explanation.py](snippets/reflection_explanation.py) - Iterative explanation improvement
+- [reflection_code_review.py](snippets/reflection_code_review.py) - Code review with self-critique
 
-- [Reflection Pattern Example](snippets/reflection/basic_reflection.py)
-- [Tool Use Pattern Example](snippets/tool_use/function_calling.py)
-- [ReAct Pattern Example](snippets/react/simple_react_loop.py)
-- [Planning Pattern Example](snippets/planning/multi_step_plan.py)
-- [Multi-Agent Pattern Example](snippets/multi_agent/collaborative_agents.py)
+### ReAct Pattern
+- [react_research.py](snippets/react_research.py) - Structured research tasks
+- [react_problem_solving.py](snippets/react_problem_solving.py) - Step-by-step problem solving
+
+### Planning Pattern
+- [planning_project.py](snippets/planning_project.py) - Project planning and breakdown
+- [planning_analysis.py](snippets/planning_analysis.py) - Data analysis planning
+
+### Tool Use Pattern
+- [tool_use_calculator.py](snippets/tool_use_calculator.py) - Mathematical operations with tools
+- [tool_use_data_processing.py](snippets/tool_use_data_processing.py) - Data validation and transformation
+
+### Multi-Agent Pattern
+- [multi_agent_collaboration.py](snippets/multi_agent_collaboration.py) - Collaborative multi-agent workflow
+
+Run any snippet:
+```bash
+python snippets/reflection_explanation.py
+python snippets/react_research.py
+python snippets/planning_project.py
+```
 
 ## Contributing