pygeai-orchestration 0.1.0b2__py3-none-any.whl

pygeai_orchestration/tests/test_metrics.py

@@ -0,0 +1,171 @@
+import time
+import unittest
+
+from pygeai_orchestration.core.utils.metrics import (
+    GlobalMetrics,
+    Metric,
+    MetricsCollector,
+)
+
+
+class TestMetricsCollector(unittest.TestCase):
+    def setUp(self):
+        self.collector = MetricsCollector()
+
+    def test_increment_counter(self):
+        self.collector.increment("requests")
+        self.assertEqual(self.collector.get_counter("requests"), 1.0)
+
+        self.collector.increment("requests", 2.0)
+        self.assertEqual(self.collector.get_counter("requests"), 3.0)
+
+    def test_counter_with_labels(self):
+        self.collector.increment("requests", labels={"method": "GET"})
+        self.collector.increment("requests", labels={"method": "POST"})
+        self.collector.increment("requests", labels={"method": "GET"})
+
+        self.assertEqual(
+            self.collector.get_counter("requests", labels={"method": "GET"}), 2.0
+        )
+        self.assertEqual(
+            self.collector.get_counter("requests", labels={"method": "POST"}), 1.0
+        )
+
+    def test_set_gauge(self):
+        self.collector.set_gauge("memory_usage", 1024.0)
+        self.assertEqual(self.collector.get_gauge("memory_usage"), 1024.0)
+
+        self.collector.set_gauge("memory_usage", 2048.0)
+        self.assertEqual(self.collector.get_gauge("memory_usage"), 2048.0)
+
+    def test_gauge_with_labels(self):
+        self.collector.set_gauge("cpu_usage", 50.0, labels={"core": "0"})
+        self.collector.set_gauge("cpu_usage", 75.0, labels={"core": "1"})
+
+        self.assertEqual(
+            self.collector.get_gauge("cpu_usage", labels={"core": "0"}), 50.0
+        )
+        self.assertEqual(
+            self.collector.get_gauge("cpu_usage", labels={"core": "1"}), 75.0
+        )
+
+    def test_record_histogram(self):
+        values = [10.0, 20.0, 30.0, 40.0, 50.0]
+        for value in values:
+            self.collector.record_histogram("response_size", value)
+
+        stats = self.collector.get_histogram_stats("response_size")
+        self.assertEqual(stats["count"], 5)
+        self.assertEqual(stats["sum"], 150.0)
+        self.assertEqual(stats["min"], 10.0)
+        self.assertEqual(stats["max"], 50.0)
+        self.assertEqual(stats["mean"], 30.0)
+
+    def test_record_timer(self):
+        durations = [0.1, 0.2, 0.3, 0.4, 0.5]
+        for duration in durations:
+            self.collector.record_timer("request_duration", duration)
+
+        stats = self.collector.get_timer_stats("request_duration")
+        self.assertEqual(stats["count"], 5)
+        self.assertAlmostEqual(stats["sum"], 1.5, places=1)
+        self.assertEqual(stats["min"], 0.1)
+        self.assertEqual(stats["max"], 0.5)
+
+    def test_timer_context(self):
+        with self.collector.timer("operation_duration"):
+            time.sleep(0.01)
+
+        stats = self.collector.get_timer_stats("operation_duration")
+        self.assertEqual(stats["count"], 1)
+        self.assertGreater(stats["min"], 0.0)
+
+    def test_timer_context_with_labels(self):
+        with self.collector.timer("db_query", labels={"table": "users"}):
+            time.sleep(0.01)
+
+        stats = self.collector.get_timer_stats("db_query", labels={"table": "users"})
+        self.assertEqual(stats["count"], 1)
+
+    def test_percentiles(self):
+        values = list(range(1, 101))
+        for value in values:
+            self.collector.record_histogram("test_percentiles", float(value))
+
+        stats = self.collector.get_histogram_stats("test_percentiles")
+        self.assertAlmostEqual(stats["p50"], 50.0, delta=5.0)
+        self.assertAlmostEqual(stats["p95"], 95.0, delta=5.0)
+        self.assertAlmostEqual(stats["p99"], 99.0, delta=5.0)
+
+    def test_get_all_metrics(self):
+        self.collector.increment("counter1")
+        self.collector.set_gauge("gauge1", 100.0)
+        self.collector.record_histogram("histogram1", 50.0)
+
+        metrics = self.collector.get_all_metrics()
+        self.assertGreaterEqual(len(metrics), 3)
+        self.assertTrue(all(isinstance(m, Metric) for m in metrics))
+
+    def test_get_summary(self):
+        self.collector.increment("requests")
+        self.collector.set_gauge("memory", 1024.0)
+        self.collector.record_histogram("sizes", 100.0)
+        self.collector.record_timer("durations", 0.5)
+
+        summary = self.collector.get_summary()
+        self.assertIn("counters", summary)
+        self.assertIn("gauges", summary)
+        self.assertIn("histograms", summary)
+        self.assertIn("timers", summary)
+
+    def test_clear(self):
+        self.collector.increment("counter")
+        self.collector.set_gauge("gauge", 100.0)
+        self.collector.record_histogram("histogram", 50.0)
+
+        self.collector.clear()
+
+        self.assertEqual(self.collector.get_counter("counter"), 0.0)
+        self.assertIsNone(self.collector.get_gauge("gauge"))
+        self.assertEqual(len(self.collector.get_all_metrics()), 0)
+
+    def test_empty_histogram_stats(self):
+        stats = self.collector.get_histogram_stats("nonexistent")
+        self.assertEqual(stats, {})
+
+    def test_empty_timer_stats(self):
+        stats = self.collector.get_timer_stats("nonexistent")
+        self.assertEqual(stats, {})
+
+
+class TestGlobalMetrics(unittest.TestCase):
+    def setUp(self):
+        GlobalMetrics.reset()
+
+    def tearDown(self):
+        GlobalMetrics.reset()
+
+    def test_singleton(self):
+        collector1 = GlobalMetrics.get_collector()
+        collector2 = GlobalMetrics.get_collector()
+        self.assertIs(collector1, collector2)
+
+    def test_global_metrics_persistence(self):
+        collector1 = GlobalMetrics.get_collector()
+        collector1.increment("global_counter")
+
+        collector2 = GlobalMetrics.get_collector()
+        self.assertEqual(collector2.get_counter("global_counter"), 1.0)
+
+    def test_reset(self):
+        collector1 = GlobalMetrics.get_collector()
+        collector1.increment("counter")
+
+        GlobalMetrics.reset()
+
+        collector2 = GlobalMetrics.get_collector()
+        self.assertEqual(collector2.get_counter("counter"), 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

pygeai_orchestration/tests/test_patterns.py

@@ -0,0 +1,165 @@
+import unittest
+import asyncio
+from pygeai_orchestration import (
+    ReflectionPattern,
+    ToolUsePattern,
+    ReActPattern,
+    PlanningPattern,
+    MultiAgentPattern,
+    AgentRole,
+    BaseTool,
+    ToolConfig,
+    ToolResult,
+    ToolCategory,
+    PatternType
+)
+
+
+class MockAgent:
+    """Mock agent for testing."""
+
+    async def generate(self, prompt: str) -> str:
+        if "Review your previous response" in prompt:
+            return "Improved response"
+        elif "TOOL_CALL" in prompt or "FINAL_ANSWER" in prompt:
+            return "FINAL_ANSWER: Test answer"
+        elif "Thought:" in prompt or "Action:" in prompt:
+            return "Thought: Test\nAction: ANSWER Test result\nObservation: Done"
+        elif "step-by-step plan" in prompt:
+            return "1. First step\n2. Second step"
+        elif "Execute the following step" in prompt:
+            return "Step completed"
+        elif "synthesized answer" in prompt or "Synthesize" in prompt:
+            return "Final synthesized result"
+        elif "coordination plan" in prompt:
+            return "Coordination plan created"
+        return "Test response"
+
+
+class MockTool(BaseTool):
+    """Mock tool for testing."""
+
+    def __init__(self):
+        config = ToolConfig(
+            name="mock_tool",
+            description="Mock tool",
+            category=ToolCategory.CUSTOM
+        )
+        super().__init__(config)
+
+    async def execute(self, **kwargs) -> ToolResult:
+        return ToolResult(success=True, result="Tool result")
+
+    def validate_parameters(self, parameters):
+        return True
+
+
+class TestReflectionPattern(unittest.TestCase):
+
+    def test_creation(self):
+        agent = MockAgent()
+        pattern = ReflectionPattern(agent=agent)
+
+        self.assertEqual(pattern.name, "reflection")
+        self.assertEqual(pattern.pattern_type, PatternType.REFLECTION)
+        self.assertEqual(pattern.current_iteration, 0)
+
+    def test_execute(self):
+        agent = MockAgent()
+        pattern = ReflectionPattern(agent=agent)
+
+        result = asyncio.run(pattern.execute("Test task"))
+
+        self.assertTrue(result.success)
+        self.assertIsNotNone(result.result)
+        self.assertGreater(result.iterations, 0)
+
+
+class TestToolUsePattern(unittest.TestCase):
+
+    def test_creation(self):
+        agent = MockAgent()
+        tool = MockTool()
+        pattern = ToolUsePattern(agent=agent, tools=[tool])
+
+        self.assertEqual(pattern.name, "tool_use")
+        self.assertEqual(pattern.pattern_type, PatternType.TOOL_USE)
+        self.assertIn("mock_tool", pattern.tools)
+
+    def test_execute(self):
+        agent = MockAgent()
+        tool = MockTool()
+        pattern = ToolUsePattern(agent=agent, tools=[tool])
+
+        result = asyncio.run(pattern.execute("Test task"))
+
+        self.assertTrue(result.success)
+        self.assertIsNotNone(result.result)
+
+
+class TestReActPattern(unittest.TestCase):
+
+    def test_creation(self):
+        agent = MockAgent()
+        pattern = ReActPattern(agent=agent)
+
+        self.assertEqual(pattern.name, "react")
+        self.assertEqual(pattern.pattern_type, PatternType.REACT)
+
+    def test_execute(self):
+        agent = MockAgent()
+        pattern = ReActPattern(agent=agent, tools=[])
+
+        result = asyncio.run(pattern.execute("Test task"))
+
+        self.assertTrue(result.success)
+        self.assertIn('thoughts', result.metadata)
+        self.assertIn('actions', result.metadata)
+
+
+class TestPlanningPattern(unittest.TestCase):
+
+    def test_creation(self):
+        agent = MockAgent()
+        pattern = PlanningPattern(agent=agent)
+
+        self.assertEqual(pattern.name, "planning")
+        self.assertEqual(pattern.pattern_type, PatternType.PLANNING)
+
+    def test_execute(self):
+        agent = MockAgent()
+        pattern = PlanningPattern(agent=agent)
+
+        result = asyncio.run(pattern.execute("Test task"))
+
+        self.assertTrue(result.success)
+        self.assertIn('plan', result.metadata)
+        self.assertGreater(len(pattern.get_plan()), 0)
+
+
+class TestMultiAgentPattern(unittest.TestCase):
+
+    def test_creation(self):
+        agent = MockAgent()
+        role = AgentRole(name="test", agent=agent, role_description="Test role")
+        pattern = MultiAgentPattern(agents=[role], coordinator_agent=agent)
+
+        self.assertEqual(pattern.name, "multi_agent")
+        self.assertEqual(pattern.pattern_type, PatternType.MULTI_AGENT)
+        self.assertIn("test", pattern.agent_roles)
+
+    def test_execute(self):
+        agent = MockAgent()
+        role1 = AgentRole(name="agent1", agent=agent, role_description="Role 1")
+        role2 = AgentRole(name="agent2", agent=agent, role_description="Role 2")
+        pattern = MultiAgentPattern(agents=[role1, role2], coordinator_agent=agent)
+
+        result = asyncio.run(pattern.execute("Test task"))
+
+        self.assertTrue(result.success)
+        self.assertIn('contributions', result.metadata)
+        self.assertEqual(len(result.metadata['contributions']), 2)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai_orchestration-0.1.0b2.dist-info/METADATA

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: pygeai-orchestration
+Version: 0.1.0b2
+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
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygeai>=0.7.0b9
+Requires-Dist: pydantic>=2.11.3
+Requires-Dist: typing-extensions>=4.13.2
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: sphinx-markdown-builder; extra == "docs"
+Provides-Extra: tests
+Requires-Dist: coverage; extra == "tests"
+Dynamic: license-file
+
+# PyGEAI-Orchestration - Agentic AI Orchestration Patterns
+
+PyGEAI-Orchestration is a complementary package to [PyGEAI](https://pypi.org/project/pygeai/) that implements agentic AI orchestration patterns built on top of [Globant Enterprise AI](https://wiki.genexus.com/enterprise-ai/wiki?8,Table+of+contents%3AEnterprise+AI). It provides powerful orchestration capabilities similar to AutoGen and CrewAI, designed specifically for the Globant Enterprise AI platform.
+
+> [!WARNING]
+> This project is in Alpha stage and it's NOT suitable for production yet.
+> While you can install the package and try it out, it's recommended to avoid using it in production until version 1.0.0
+> is released
+
+## Features
+
+**Multiple Orchestration Patterns**
+- **Reflection Pattern**: Self-critique and iterative improvement
+- **Tool Use Pattern**: Function calling and tool integration
+- **ReAct Pattern**: Reasoning + Acting loop for complex problem-solving
+- **Planning Pattern**: Multi-step planning and execution
+- **Multi-Agent Pattern**: Collaborative agent coordination
+
+**Built on PyGEAI**
+- Leverages PyGEAI's robust SDK capabilities
+- Seamless integration with Globant Enterprise AI
+- No code duplication - reuses PyGEAI infrastructure
+
+**Easy to Use**
+- Simple CLI tool: `geai-orch`
+- Pythonic API for programmatic access
+- Rich examples and documentation
+
+## Installation
+
+```bash
+pip install pygeai-orchestration
+```
+
+**Requirements:**
+- Python >= 3.10
+- PyGEAI >= 0.7.0b9
+
+## Quick Start
+
+### CLI Usage
+
+```bash
+# Run a reflection pattern
+geai-orch reflection --agent my-agent --iterations 3
+
+# Execute a ReAct pattern
+geai-orch react --agent reasoning-agent --task "Solve complex problem"
+
+# Multi-agent collaboration
+geai-orch multi-agent --config agents.yaml
+```
+
+### Python API
+
+```python
+import asyncio
+from pygeai_orchestration import (
+    GEAIAgent,
+    AgentConfig,
+    ReflectionPattern
+)
+
+async def main():
+    # Create an agent
+    config = AgentConfig(
+        name="my-agent",
+        model="gpt-4",
+        temperature=0.7
+    )
+    agent = GEAIAgent(config)
+    
+    # Create and execute pattern
+    pattern = ReflectionPattern(agent=agent)
+    result = await pattern.execute("Improve this text: Hello world")
+    
+    print(f"Success: {result.success}")
+    print(f"Result: {result.result}")
+    print(f"Iterations: {result.iterations}")
+
+asyncio.run(main())
+```
+
+## Configuration
+
+PyGEAI-Orchestration uses the same configuration as PyGEAI. Set up your credentials using one of these methods:
+
+**Environment Variables:**
+```bash
+export GEAI_API_KEY=<your-api-key>
+export GEAI_API_BASE_URL=<base-url>
+```
+
+**Credentials File:**
+Create `$USER_HOME/.geai/credentials`:
+```ini
+[default]
+geai_api_key = <API_TOKEN>
+geai_api_base_url = <GEAI_BASE_URL>
+```
+
+See [PyGEAI Configuration](https://github.com/genexus-books/pygeai#configuration) for more details.
+
+## Orchestration Patterns
+
+### 1. Reflection Pattern
+Enables agents to self-critique and iteratively improve their outputs.
+
+```python
+from pygeai_orchestration.patterns.reflection import ReflectionAgent
+
+agent = ReflectionAgent(session=session, agent_id="critic-agent")
+result = agent.reflect_and_improve("Initial output", iterations=3)
+```
+
+**Use Cases:**
+- Content quality improvement
+- 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
+Implements the Reasoning + Acting loop for step-by-step problem solving.
+
+```python
+from pygeai_orchestration.patterns.react import ReActAgent
+
+agent = ReActAgent(session=session, agent_id="reasoning-agent")
+result = agent.solve("Complex multi-step problem")
+```
+
+**Use Cases:**
+- Complex problem solving
+- Research tasks
+- Multi-step workflows
+
+### 4. Planning Pattern
+Creates and executes multi-step plans with adaptive execution.
+
+```python
+from pygeai_orchestration.patterns.planning import PlanningAgent
+
+agent = PlanningAgent(session=session, planner_id="planner")
+plan = agent.create_plan("Build a web application")
+result = agent.execute_plan(plan)
+```
+
+**Use Cases:**
+- Project planning
+- Task decomposition
+- Workflow automation
+
+### 5. Multi-Agent Pattern
+Coordinates multiple agents working collaboratively on complex tasks.
+
+```python
+from pygeai_orchestration.patterns.multi_agent import MultiAgentCoordinator
+
+coordinator = MultiAgentCoordinator(session=session)
+coordinator.add_agent("researcher", researcher_agent)
+coordinator.add_agent("writer", writer_agent)
+result = coordinator.execute("Create research report")
+```
+
+**Use Cases:**
+- Team collaboration simulation
+- Complex task delegation
+- Specialized agent workflows
+
+## Documentation
+
+- [Getting Started Guide](docs/getting-started.md)
+- [Pattern Documentation](docs/patterns/)
+- [API Reference](docs/api-reference/)
+- [Examples](snippets/)
+
+## Development
+
+### Setup Development Environment
+
+```bash
+git clone https://github.com/genexus-books/pygeai-orchestration.git
+cd pygeai-orchestration
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -r requirements.txt
+pip install -e .
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+python testing.py
+
+# Run specific pattern tests
+python -m unittest pygeai_orchestration.tests.patterns.test_reflection
+
+# Check coverage
+python testing.py --coverage
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development guidelines.
+
+## Examples
+
+Check the [snippets/](snippets/) directory for working examples of each pattern:
+
+- [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)
+
+## Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+This project is licensed under the MIT License - see [LICENSE](LICENSE) for details.
+
+## Terms and Conditions
+
+By using this SDK, you agree to the [Globant Enterprise AI Terms of Use](https://www.globant.com/enterprise-ai/terms-of-use).
+
+## Support
+
+- [Documentation](docs/)
+- [Issue Tracker](https://github.com/genexus-books/pygeai-orchestration/issues)
+- [Discussions](https://github.com/genexus-books/pygeai-orchestration/discussions)
+
+## Related Projects
+
+- [PyGEAI](https://github.com/genexus-books/pygeai) - Core SDK for Globant Enterprise AI
+- [AutoGen](https://github.com/microsoft/autogen) - Multi-agent framework by Microsoft
+- [CrewAI](https://github.com/joaomdmoura/crewAI) - Framework for orchestrating AI agents
+
+## Compatibility
+
+This package is compatible with Globant Enterprise AI release from February 2026 and requires PyGEAI >= 0.7.0b9.
+
+---
+
+**Made by Globant**

pygeai_orchestration-0.1.0b2.dist-info/RECORD

@@ -0,0 +1,61 @@
+pygeai_orchestration/__init__.py,sha256=phPtSd0SgtSOicRoZAbgkSQCPv0wPeWHWz-lpcEujx0,1820
+pygeai_orchestration/cli/__init__.py,sha256=d6wFWuMlcMLng3lBfjSOfhnO_tZINHfNUOmA7-zwPX4,134
+pygeai_orchestration/cli/__main__.py,sha256=2AmJiRvdlVSu3T6FmFAzQuu4a5llrUeMfUX8ShQxhus,157
+pygeai_orchestration/cli/error_handler.py,sha256=ReeeeX2TvJZBgdCc0hzvLZd8LYSQVqYI5hAEqJ4FCCM,3862
+pygeai_orchestration/cli/formatters.py,sha256=pCS8gZ0k7AKWkLFDPrSQ_UpLGqv4nPyGxnNDwCO4wFc,11037
+pygeai_orchestration/cli/geai_orch.py,sha256=2LjVU4hlgmAQ2FBp6j0rWcXXy1EiflpxcuVTLvikCAs,11307
+pygeai_orchestration/cli/interactive.py,sha256=KVZzgjMS89dDQM25XohcFb3dTbjpMsWV_Z9uMzZ-fjY,7912
+pygeai_orchestration/cli/commands/__init__.py,sha256=PLWgWUXomwNCqR-wrl_-fWOYFN8PeIAvPnYvmzvzg0w,232
+pygeai_orchestration/cli/commands/base.py,sha256=BWjuxk06KkRVozCMbwjD_pkzrsAHWE9TgVKQegkIHoM,6558
+pygeai_orchestration/cli/texts/help.py,sha256=vHAA-2SSrSYpQLfLp3Ruz0-WEVb8UmCahgDkOZEcGGI,5423
+pygeai_orchestration/core/__init__.py,sha256=muVm1M6yfTgYDL6Fe1h6hdKB8QLJKQrWBgRj3svOSlk,2380
+pygeai_orchestration/core/composition.py,sha256=j_mV0iNJfPkCO8h1rrzKY0eL00g77C8D_Hy6qPnDaMw,6654
+pygeai_orchestration/core/config.py,sha256=m2dbBejao9ku0od4jYo4Xn-HmDvq_d44EYJkZKGgd4I,11493
+pygeai_orchestration/core/exceptions.py,sha256=nZWQlPFQtyGmx-qtErydXvIfiqkXuBlsxoofDyDoRLQ,13282
+pygeai_orchestration/core/handlers.py,sha256=6OMo3xZvHwITdn8J4kX7Wi65iWGRwnL0ioHLNmFWwBQ,13474
+pygeai_orchestration/core/base/__init__.py,sha256=VuUeoAVxKN1DOXMLKwkhPSkfMFVcKPwU0LP5M9jKeaM,622
+pygeai_orchestration/core/base/agent.py,sha256=J_xRVE1MXPbXWC1ndwMHMVWY44S0myIzNfVPJzoE7Lo,4446
+pygeai_orchestration/core/base/geai_agent.py,sha256=PG0X8gmKiU0MxkRKJchvcBOztcVCk_eXwJ3kmcRi4aU,5097
+pygeai_orchestration/core/base/geai_orchestrator.py,sha256=sGEdUc4TeKJ_WiPw91FBkXCkEWO986WOXbm9LMp6CL8,2730
+pygeai_orchestration/core/base/orchestrator.py,sha256=83BIjYerW1ADnzWG_GGIzLTZF_nS93cb4uXp9KWryAU,4835
+pygeai_orchestration/core/base/pattern.py,sha256=vuj1UXLuaZvbhjiifwqThnQ_4uaRBkv2VQ5FBrY8Xxs,6114
+pygeai_orchestration/core/base/tool.py,sha256=sypjwrMKiiuwi6VmbXIVoIOkQ4RZWpZD0aSlOCKYOSs,5491
+pygeai_orchestration/core/common/__init__.py,sha256=akhDVqt8uFH0u2k4w_STrKZJ3ndjtpRDkp46baxCn6U,416
+pygeai_orchestration/core/common/context.py,sha256=mMch8-9mLReYglBMbIB2RCDYn7EGjzsp2kgaO3mwHG8,4321
+pygeai_orchestration/core/common/memory.py,sha256=1jYrqc1sPJujuIcNQLITXbKnQ_WMGjkvcNTMDkoQU9o,5841
+pygeai_orchestration/core/common/message.py,sha256=4JB3ZPeegaRvEYf1MKy7NBHm76oCBYf8V6cuNIf9kzw,1732
+pygeai_orchestration/core/common/state.py,sha256=mHo7ozjvPdHZfd-sbVg6t9HLND7ll1xD6sm6v8nCrb4,5690
+pygeai_orchestration/core/utils/__init__.py,sha256=-DVGUjf1t4XeWNk4SPrMTJcVI1Nf87-j-QJ_7EagsPI,819
+pygeai_orchestration/core/utils/cache.py,sha256=TJLtj115EXqlLrKLMoK7JCT-fZ1TGSjVxmJyW6n2p8c,4108
+pygeai_orchestration/core/utils/config.py,sha256=S2gzAsL20-h_AEFDj0izjlXhWucBLwbE7Vv4ovUiJIM,2775
+pygeai_orchestration/core/utils/logging.py,sha256=BPi0s9dU4i6e4E2HZU1omqI79JhaJ9js533RG_BFAtE,1812
+pygeai_orchestration/core/utils/metrics.py,sha256=Kw8hA-PS6UHMLf0pEG2XQZvcBbuIFhHdo1kWEMf6Vz8,6359
+pygeai_orchestration/core/utils/validators.py,sha256=EoVQSrJDmM8dGlqAoM_1q3B7SBAyI3yuLfcj3weZuio,5146
+pygeai_orchestration/dev/__init__.py,sha256=e-GSMmpkN1cINRDtInrjKTQogSJ2h-Q1ya_YaaMRF5s,476
+pygeai_orchestration/dev/debug.py,sha256=0RJed1TCreaSm7HC9ijbd9EeMoh3zFn4osjrYDcY5sQ,8444
+pygeai_orchestration/dev/templates.py,sha256=J57-8Stg_m-f-cj_Zl9Yz_VNEZA-trGM8SKdsdzH7NQ,8143
+pygeai_orchestration/dev/testing.py,sha256=_zXvj3JHJNFEbZJnK-OdtL_tD-3xQeCHMrJ39UYqaqg,7826
+pygeai_orchestration/patterns/__init__.py,sha256=W5qROE1pbeVOgPx6xiKZtQp0eQPL9kEhL6Et3t6kBA8,376
+pygeai_orchestration/patterns/multi_agent.py,sha256=fe_9AS2L7b_M0-ahcwCgBjh_s8zYUi1nz7nS6OD5E6I,9857
+pygeai_orchestration/patterns/planning.py,sha256=JITIexKfmc1H2KTVCxbq9EhMGbwbYo4xwfVttW5zsc0,8885
+pygeai_orchestration/patterns/react.py,sha256=P1aNgjgrEPP-zUO5OfUx0q2GO9J_yvRakirRFiPJfho,9320
+pygeai_orchestration/patterns/reflection.py,sha256=KRthEpuGKH3LM0ceY0cahpC9kAmmH8HqXeF63r_kqUY,5728
+pygeai_orchestration/patterns/tool_use.py,sha256=trJPV_SzXOD6mXIAivJASHaahxYQZjBZcVmV57QQUv4,7594
+pygeai_orchestration/tests/__init__.py,sha256=nzx1KsiYalL_YuXKE6acW8Dj5flmMg0-i4gyYO0gV54,22
+pygeai_orchestration/tests/test_base_classes.py,sha256=9VcME1C1fY1cijblzh639ZQhV6-iWGuEx80kDRpDr6k,5673
+pygeai_orchestration/tests/test_cache.py,sha256=t_iYB_La1mkKBEnFinl10kNa1IVtW_yWjKq0dz8-Z4w,5705
+pygeai_orchestration/tests/test_cli_formatters.py,sha256=Gpg6OOstFR3L7Mwk8cpmFSupP67tr3PAgFTvaKYYfA4,7856
+pygeai_orchestration/tests/test_common.py,sha256=AiRIWh7_vlSVs35ZSPvTY5YukZbtpMO_q1LK5_o7lKA,5659
+pygeai_orchestration/tests/test_composition.py,sha256=N1BC8_EEehm5wUuYlxe3UwhtcrAodmUjrDS2Ae4iR8M,9765
+pygeai_orchestration/tests/test_config.py,sha256=vvzAApuVgwQyFt6J7hPDwrxHfthI8ENWPDLApWDe3i4,10253
+pygeai_orchestration/tests/test_dev_utils.py,sha256=XaG-xWcLTNFDYIOaLAQvC6pfaCtLddksuW9FWWQV2Ao,10701
+pygeai_orchestration/tests/test_exceptions.py,sha256=l_YlVxZguM-xcUNlOl8u9R3vx_Oa70vtFHQPDd_0PSQ,10919
+pygeai_orchestration/tests/test_handlers.py,sha256=t3ZCbif4npxsgoYM6vpCrxOru0q-7f0ARjYAE1SuK7Y,12166
+pygeai_orchestration/tests/test_metrics.py,sha256=GP36BuTxp7ydptG4nGo804yB91UkBHuskEfJuZwkZvE,6078
+pygeai_orchestration/tests/test_patterns.py,sha256=9qarHU_9R70nfWf98TzMiJO_XCfz9-kOn9Ju2RQnogs,5051
+pygeai_orchestration-0.1.0b2.dist-info/licenses/LICENSE,sha256=HrOw5fbeVfHobmqgadP4r7dOPCMDA4uOfFX8pE3MDT0,1072
+pygeai_orchestration-0.1.0b2.dist-info/METADATA,sha256=KEMGd394CJL1hTk9pugoM0dzTnBsN9_BaVqdgU8KsGc,8383
+pygeai_orchestration-0.1.0b2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pygeai_orchestration-0.1.0b2.dist-info/entry_points.txt,sha256=p8ODRFqLwrrhoS6FlQW330_J59-0ZjSd6x8kAYYLm7E,69
+pygeai_orchestration-0.1.0b2.dist-info/top_level.txt,sha256=8gLeyR8RXLump7AkakhU7kFBh6O7XTvrJi1bKK4e39g,21
+pygeai_orchestration-0.1.0b2.dist-info/RECORD,,

pygeai_orchestration-0.1.0b2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+