genxai-framework 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

genxai/flows/router.py

@@ -0,0 +1,45 @@
+"""Rule-based routing flow orchestrator."""
+
+from typing import Callable, List
+
+from genxai.core.graph.engine import Graph
+from genxai.core.graph.edges import Edge
+from genxai.core.graph.nodes import AgentNode, InputNode, OutputNode
+from genxai.flows.base import FlowOrchestrator
+
+
+class RouterFlow(FlowOrchestrator):
+    """Route to an agent based on deterministic routing rules."""
+
+    def __init__(
+        self,
+        agents: List,
+        router: Callable[[dict], str],
+        name: str = "router_flow",
+        llm_provider=None,
+    ) -> None:
+        super().__init__(agents=agents, name=name, llm_provider=llm_provider)
+        self.router = router
+
+    def build_graph(self) -> Graph:
+        graph = Graph(name=self.name)
+        start = InputNode(id="input")
+        graph.add_node(start)
+
+        end = OutputNode(id="output")
+        graph.add_node(end)
+        nodes = self._agent_nodes()
+        for node in nodes:
+            graph.add_node(node)
+            graph.add_edge(
+                Edge(
+                    source=start.id,
+                    target=node.id,
+                    condition=lambda state, agent_id=node.id: self.router(state) == agent_id,
+                )
+            )
+            graph.add_edge(Edge(source=node.id, target=end.id))
+
+        graph.add_edge(Edge(source=start.id, target=end.id))
+
+        return graph

genxai/flows/selector.py

@@ -0,0 +1,63 @@
+"""Selector-based flow orchestrator."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional
+
+from genxai.core.graph.engine import Graph
+from genxai.core.graph.nodes import AgentNode
+from genxai.flows.base import FlowOrchestrator
+
+
+class SelectorFlow(FlowOrchestrator):
+    """Route to the next agent using a selector function.
+
+    The selector function returns the agent ID to execute next.
+    """
+
+    def __init__(
+        self,
+        agents: List[Any],
+        selector: Callable[[Dict[str, Any], List[str]], str],
+        name: str = "selector_flow",
+        llm_provider: Any = None,
+        max_hops: int = 1,
+    ) -> None:
+        super().__init__(agents=agents, name=name, llm_provider=llm_provider)
+        self.selector = selector
+        self.max_hops = max_hops
+
+    def build_graph(self) -> Graph:
+        graph = Graph(name=self.name)
+        nodes: List[AgentNode] = self._agent_nodes()
+
+        for node in nodes:
+            graph.add_node(node)
+
+        return graph
+
+    async def run(
+        self,
+        input_data: Any,
+        state: Optional[Dict[str, Any]] = None,
+        max_iterations: int = 100,
+    ) -> Dict[str, Any]:
+        graph = self.build_graph()
+        if state is None:
+            state = {}
+
+        state["input"] = input_data
+        agent_ids = [agent.id for agent in self.agents]
+
+        for hop in range(self.max_hops):
+            selected = self.selector(state, agent_ids)
+            if selected not in agent_ids:
+                raise ValueError(
+                    f"SelectorFlow returned unknown agent id '{selected}'."
+                )
+
+            state["next_agent"] = selected
+            state["selector_hop"] = hop + 1
+            await graph._execute_node(selected, state, max_iterations)
+
+        return state

genxai/flows/subworkflow.py

@@ -0,0 +1,35 @@
+"""Subworkflow flow orchestrator."""
+
+from typing import Any, Dict, Optional
+
+from genxai.core.graph.engine import Graph
+from genxai.flows.base import FlowOrchestrator
+
+
+class SubworkflowFlow(FlowOrchestrator):
+    """Execute a pre-built subgraph as a flow."""
+
+    def __init__(
+        self,
+        graph: Graph,
+        name: str = "subworkflow_flow",
+        llm_provider: Any = None,
+    ) -> None:
+        super().__init__(agents=[], name=name, llm_provider=llm_provider, allow_empty_agents=True)
+        self.graph = graph
+
+    def build_graph(self) -> Graph:
+        return self.graph
+
+    async def run(
+        self,
+        input_data: Any,
+        state: Optional[Dict[str, Any]] = None,
+        max_iterations: int = 100,
+    ) -> Dict[str, Any]:
+        return await self.graph.run(
+            input_data=input_data,
+            state=state,
+            max_iterations=max_iterations,
+            llm_provider=self.llm_provider,
+        )

genxai/llm/factory.py

@@ -37,6 +37,11 @@ class LLMProviderFactory:
         "claude-3-opus": "genxai.llm.providers.anthropic.AnthropicProvider",
         "claude-3-sonnet": "genxai.llm.providers.anthropic.AnthropicProvider",
         "claude-3-haiku": "genxai.llm.providers.anthropic.AnthropicProvider",
+        "claude-3-5-sonnet-20241022": "genxai.llm.providers.anthropic.AnthropicProvider",
+        "claude-3-5-sonnet-20240620": "genxai.llm.providers.anthropic.AnthropicProvider",
+        "claude-3-opus-20240229": "genxai.llm.providers.anthropic.AnthropicProvider",
+        "claude-3-sonnet-20240229": "genxai.llm.providers.anthropic.AnthropicProvider",
+        "claude-3-haiku-20240307": "genxai.llm.providers.anthropic.AnthropicProvider",
         "google": "genxai.llm.providers.google.GoogleProvider",
         "gemini-pro": "genxai.llm.providers.google.GoogleProvider",
         "gemini-ultra": "genxai.llm.providers.google.GoogleProvider",
@@ -235,41 +240,43 @@ class LLMProviderFactory:
         Returns:
             Provider class or None
         """
+        model_key = model.lower()
+
         # Direct match in pre-loaded providers
-        if model in cls._providers:
-            return cls._providers[model]
+        if model_key in cls._providers:
+            return cls._providers[model_key]
 
         # Check lazy-loaded providers
-        if model in cls._provider_modules:
-            provider_class = cls._load_provider_class(cls._provider_modules[model])
+        if model_key in cls._provider_modules:
+            provider_class = cls._load_provider_class(cls._provider_modules[model_key])
             if provider_class:
                 # Cache it for future use
-                cls._providers[model] = provider_class
+                cls._providers[model_key] = provider_class
                 return provider_class
 
         # Check if model starts with known provider prefix
-        model_lower = model.lower()
+        model_lower = model_key
         if model_lower.startswith("gpt"):
             return OpenAIProvider
         elif model_lower.startswith("claude"):
             provider_class = cls._load_provider_class("genxai.llm.providers.anthropic.AnthropicProvider")
             if provider_class:
-                cls._providers[model] = provider_class
+                cls._providers[model_key] = provider_class
                 return provider_class
         elif model_lower.startswith("gemini"):
             provider_class = cls._load_provider_class("genxai.llm.providers.google.GoogleProvider")
             if provider_class:
-                cls._providers[model] = provider_class
+                cls._providers[model_key] = provider_class
                 return provider_class
         elif model_lower.startswith("command"):
             provider_class = cls._load_provider_class("genxai.llm.providers.cohere.CohereProvider")
             if provider_class:
-                cls._providers[model] = provider_class
+                cls._providers[model_key] = provider_class
                 return provider_class
         elif model_lower.startswith("llama") or model_lower.startswith("mistral") or model_lower.startswith("phi"):
             provider_class = cls._load_provider_class("genxai.llm.providers.ollama.OllamaProvider")
             if provider_class:
-                cls._providers[model] = provider_class
+                cls._providers[model_key] = provider_class
                 return provider_class
 
         return None

genxai/llm/providers/anthropic.py

@@ -12,6 +12,23 @@ logger = logging.getLogger(__name__)
 class AnthropicProvider(LLMProvider):
     """Anthropic Claude LLM provider."""
 
+    _MODEL_ALIASES = {
+        # Claude 4.5 models
+        "claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+        "claude-haiku-4-5": "claude-haiku-4-5-20251001",
+        "claude-opus-4-5": "claude-opus-4-5-20251101",
+        # Claude 4 models
+        "claude-sonnet-4": "claude-sonnet-4-20250514",
+        "claude-opus-4": "claude-opus-4-20250514",
+        "claude-opus-4-1": "claude-opus-4-1-20250805",
+        # Claude 3.5 models
+        "claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
+        # Claude 3 models
+        "claude-3-opus": "claude-3-opus-20240229",
+        "claude-3-sonnet": "claude-3-sonnet-20240229",
+        "claude-3-haiku": "claude-3-haiku-20240307",
+    }
+
     def __init__(
         self,
         model: str = "claude-3-opus-20240229",
@@ -29,7 +46,9 @@ class AnthropicProvider(LLMProvider):
             max_tokens: Maximum tokens to generate
             **kwargs: Additional Anthropic-specific parameters
         """
-        super().__init__(model, temperature, max_tokens, **kwargs)
+        resolved_model = self._normalize_model(model)
+        super().__init__(resolved_model, temperature, max_tokens, **kwargs)
+        self.requested_model = model
         
         self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
         if not self.api_key:
@@ -126,6 +145,35 @@ class AnthropicProvider(LLMProvider):
             )
 
         except Exception as e:
+            if self._is_model_not_found_error(e):
+                fallback_model = self._fallback_model(self.model)
+                if fallback_model and fallback_model != self.model:
+                    logger.warning(
+                        "Anthropic model '%s' not found. Falling back to '%s'.",
+                        self.model,
+                        fallback_model,
+                    )
+                    self.model = fallback_model
+                    params["model"] = fallback_model
+                    response = await self._client.messages.create(**params)
+                    content = response.content[0].text if response.content else ""
+                    finish_reason = response.stop_reason
+                    usage = {
+                        "prompt_tokens": response.usage.input_tokens if response.usage else 0,
+                        "completion_tokens": response.usage.output_tokens if response.usage else 0,
+                        "total_tokens": (
+                            (response.usage.input_tokens + response.usage.output_tokens)
+                            if response.usage else 0
+                        ),
+                    }
+                    self._update_stats(usage)
+                    return LLMResponse(
+                        content=content,
+                        model=response.model,
+                        usage=usage,
+                        finish_reason=finish_reason,
+                        metadata={"response_id": response.id, "type": response.type},
+                    )
             logger.error(f"Anthropic API call failed: {e}")
             raise
 
@@ -245,5 +293,72 @@ class AnthropicProvider(LLMProvider):
             )
 
         except Exception as e:
+            if self._is_model_not_found_error(e):
+                fallback_model = self._fallback_model(self.model)
+                if fallback_model and fallback_model != self.model:
+                    logger.warning(
+                        "Anthropic model '%s' not found. Falling back to '%s'.",
+                        self.model,
+                        fallback_model,
+                    )
+                    self.model = fallback_model
+                    params["model"] = fallback_model
+                    response = await self._client.messages.create(**params)
+                    content = response.content[0].text if response.content else ""
+                    finish_reason = response.stop_reason
+                    usage = {
+                        "prompt_tokens": response.usage.input_tokens if response.usage else 0,
+                        "completion_tokens": response.usage.output_tokens if response.usage else 0,
+                        "total_tokens": (
+                            (response.usage.input_tokens + response.usage.output_tokens)
+                            if response.usage else 0
+                        ),
+                    }
+                    self._update_stats(usage)
+                    return LLMResponse(
+                        content=content,
+                        model=response.model,
+                        usage=usage,
+                        finish_reason=finish_reason,
+                        metadata={"response_id": response.id, "type": response.type},
+                    )
             logger.error(f"Anthropic chat API call failed: {e}")
             raise
+
+    @classmethod
+    def _normalize_model(cls, model: str) -> str:
+        model_key = model.strip().lower()
+        return cls._MODEL_ALIASES.get(model_key, model)
+
+    @staticmethod
+    def _is_model_not_found_error(error: Exception) -> bool:
+        message = str(error).lower()
+        return "not_found_error" in message or "model:" in message
+
+    @staticmethod
+    def _fallback_model(model: str) -> Optional[str]:
+        model_lower = model.lower()
+        # Claude 4.5 fallbacks
+        if model_lower.startswith("claude-sonnet-4-5") or model_lower.startswith("claude-opus-4-5"):
+            return "claude-sonnet-4-20250514"
+        if model_lower.startswith("claude-haiku-4-5"):
+            return "claude-haiku-4-5-20251001"
+        # Claude 4 fallbacks
+        if model_lower.startswith("claude-opus-4"):
+            return "claude-sonnet-4-20250514"
+        if model_lower.startswith("claude-sonnet-4"):
+            return "claude-3-5-sonnet-20241022"
+        # Claude 3.5 fallbacks
+        if model_lower.startswith("claude-3-5"):
+            return "claude-3-sonnet-20240229"
+        # Claude 3 fallbacks
+        if model_lower.startswith("claude-3-opus"):
+            return "claude-3-sonnet-20240229"
+        if model_lower.startswith("claude-3-sonnet"):
+            return "claude-3-haiku-20240307"
+        if model_lower.startswith("claude-3-haiku"):
+            return "claude-3-haiku-20240307"
+        # Generic Claude fallback
+        if model_lower.startswith("claude"):
+            return "claude-3-haiku-20240307"
+        return None

genxai/tools/builtin/__init__.py

@@ -34,6 +34,7 @@ from genxai.tools.builtin.database.database_inspector import DatabaseInspectorTo
 
 # Communication tools
 from genxai.tools.builtin.communication.email_sender import EmailSenderTool
+from genxai.tools.builtin.communication.human_input import HumanInputTool
 from genxai.tools.builtin.communication.slack_notifier import SlackNotifierTool
 from genxai.tools.builtin.communication.sms_sender import SMSSenderTool
 from genxai.tools.builtin.communication.webhook_caller import WebhookCallerTool
@@ -75,6 +76,7 @@ _tools_to_register = [
     DatabaseInspectorTool(),
     # Communication
     EmailSenderTool(),
+    HumanInputTool(),
     SlackNotifierTool(),
     SMSSenderTool(),
     WebhookCallerTool(),
@@ -119,6 +121,7 @@ __all__ = [
     "VectorSearchTool",
     "DatabaseInspectorTool",
     "EmailSenderTool",
+    "HumanInputTool",
     "SlackNotifierTool",
     "SMSSenderTool",
     "WebhookCallerTool",

genxai/tools/builtin/communication/human_input.py

@@ -0,0 +1,32 @@
+"""Human input tool for interactive workflows."""
+
+from typing import Any, Dict
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+
+class HumanInputTool(Tool):
+    """Collect input from a human (stdin)."""
+
+    def __init__(self) -> None:
+        from genxai.tools.registry import ToolRegistry
+        super().__init__(
+            metadata=ToolMetadata(
+                name="human_input",
+                description="Collects human input from the console",
+                category=ToolCategory.CUSTOM,
+            ),
+            parameters=[
+                ToolParameter(
+                    name="prompt",
+                    type="string",
+                    description="Prompt to show the user",
+                )
+            ],
+        )
+        if ToolRegistry.get(self.metadata.name) is None:
+            ToolRegistry.register(self)
+
+    async def _execute(self, **kwargs: Any) -> Dict[str, Any]:
+        prompt = kwargs.get("prompt", "Your response:")
+        return {"response": input(f"{prompt} ")}

genxai/tools/custom/test-2.py

@@ -0,0 +1,19 @@
+"""
+Auto-generated tool: test-2
+Description: testing
+Category: custom
+Created: 2026-02-03 02:05:46.667101
+"""
+
+# Tool code
+# Access parameters via 'params' dict
+# Example: value = params.get('input_value')
+
+# Your tool logic here
+result = {
+    "message": "Hello from custom tool!",
+    "data": params
+}
+
+# Set 'result' variable with your output
+

genxai/tools/custom/test_tool_ui.py

@@ -0,0 +1,9 @@
+"""
+Auto-generated tool: test_tool_ui
+Description: test
+Category: custom
+Created: 2026-02-03 02:03:15.074097
+"""
+
+# Tool code
+result = {"message": "ok"}

genxai/tools/persistence/service.py

@@ -94,7 +94,7 @@ class ToolService:
             logger.info(f"Saved tool to database: {name}")
             
             # Optionally export to file
-            ToolService._export_to_file(tool_model)
+            # ToolService._export_to_file(tool_model)
             
             return tool_model
         except Exception as e:
@@ -153,7 +153,7 @@ class ToolService:
                 logger.info(f"Updated tool code in database: {name}")
                 
                 # Update file if exists
-                ToolService._export_to_file(tool)
+                # ToolService._export_to_file(tool)
                 
                 return True
             return False
@@ -183,7 +183,7 @@ class ToolService:
                 logger.info(f"Deleted tool from database: {name}")
                 
                 # Delete file if exists
-                ToolService._delete_file(name)
+                # ToolService._delete_file(name)
                 
                 return True
             return False

genxai/utils/tokens.py

@@ -17,8 +17,14 @@ MODEL_TOKEN_LIMITS: Dict[str, int] = {
     "gpt-3.5-turbo-16k": 16384,
     # Anthropic models
     "claude-3-opus": 200000,
+    "claude-3-opus-20240229": 200000,
     "claude-3-sonnet": 200000,
+    "claude-3-sonnet-20240229": 200000,
     "claude-3-haiku": 200000,
+    "claude-3-haiku-20240307": 200000,
+    "claude-3-5-sonnet": 200000,
+    "claude-3-5-sonnet-20241022": 200000,
+    "claude-3-5-sonnet-20240620": 200000,
     "claude-2.1": 200000,
     "claude-2": 100000,
     "claude-instant": 100000,

{genxai_framework-0.1.0.dist-info → genxai_framework-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genxai-framework
-Version: 0.1.0
+Version: 0.1.1
 Summary: Advanced Agentic AI Framework with Graph-Based Orchestration
 Author-email: GenXAI Team <team@genxai.dev>
 License: MIT
@@ -81,9 +81,9 @@ Dynamic: license-file
 
 # GenXAI - Advanced Agentic AI Framework
 
-**Version:** 1.0.0 (Design Phase)  
-**Status:** Planning & Architecture  
-**License:** MIT (Planned)
+**Version:** 1.0.0  
+**Status:** Active Development  
+**License:** MIT
 
 ---
 
@@ -155,7 +155,7 @@ Comprehensive documentation is available in the following files:
 
 - **[ARCHITECTURE.md](./ARCHITECTURE.md)** - Complete system architecture and design principles
 - **[REQUIREMENTS.md](./REQUIREMENTS.md)** - Detailed functional and non-functional requirements
-- **[IMPLEMENTATION_PLAN.md](./IMPLEMENTATION_PLAN.md)** - 20-week development roadmap
+- **[IMPLEMENTATION_PLAN.md](./IMPLEMENTATION_PLAN.md)** - Development roadmap
 - **[TOOLS_DESIGN.md](./TOOLS_DESIGN.md)** - Tool system architecture and 50+ built-in tools
 - **[MEMORY_DESIGN.md](./MEMORY_DESIGN.md)** - Multi-layered memory system design
 
@@ -229,7 +229,7 @@ See [ARCHITECTURE.md](./ARCHITECTURE.md) for complete details.
 - Beta testing
 - Official launch 🚀
 
-See [IMPLEMENTATION_PLAN.md](./IMPLEMENTATION_PLAN.md) for detailed timeline.
+See [IMPLEMENTATION_PLAN.md](./IMPLEMENTATION_PLAN.md) for the timeline.
 
 ---
 
@@ -286,6 +286,48 @@ graph.add_edge(Edge(source="support", target="end"))
 result = await graph.run(input_data="My app crashed")
 ```
 
+### Flow Orchestrator Examples
+
+GenXAI also ships with lightweight flow orchestrators for common patterns:
+
+```python
+from genxai import AgentFactory, RoundRobinFlow, SelectorFlow, P2PFlow
+
+agents = [
+    AgentFactory.create_agent(id="analyst", role="Analyst", goal="Analyze"),
+    AgentFactory.create_agent(id="writer", role="Writer", goal="Write"),
+]
+
+# Round-robin flow
+round_robin = RoundRobinFlow(agents)
+
+# Selector flow
+def choose_next(state, agent_ids):
+    return agent_ids[state.get("selector_hop", 0) % len(agent_ids)]
+
+selector = SelectorFlow(agents, selector=choose_next, max_hops=3)
+
+# P2P flow
+p2p = P2PFlow(agents, max_rounds=4, consensus_threshold=0.7)
+```
+
+See runnable examples in:
+- `examples/code/flow_round_robin_example.py`
+- `examples/code/flow_selector_example.py`
+- `examples/code/flow_p2p_example.py`
+- `examples/code/flow_parallel_example.py`
+- `examples/code/flow_conditional_example.py`
+- `examples/code/flow_loop_example.py`
+- `examples/code/flow_router_example.py`
+- `examples/code/flow_ensemble_voting_example.py`
+- `examples/code/flow_critic_review_example.py`
+- `examples/code/flow_coordinator_worker_example.py`
+- `examples/code/flow_map_reduce_example.py`
+- `examples/code/flow_subworkflow_example.py`
+- `examples/code/flow_auction_example.py`
+
+Full flow documentation: [docs/FLOWS.md](./docs/FLOWS.md)
+
 ### Trigger SDK Quick Start
 
 ```python
@@ -350,6 +392,16 @@ workflow:
         condition: "category == 'technical'"
 ```
 
+Shared memory template:
+
+```bash
+genxai workflow run examples/nocode/shared_memory_workflow.yaml \
+  --input '{"task": "Draft a short response"}'
+```
+
+See no-code templates (including a shared memory example) in:
+- `examples/nocode/README.md`
+
 ---
 
 ## 🛠️ Technology Stack
@@ -443,10 +495,9 @@ workflow:
 
 ## 🤝 Contributing
 
-We welcome contributions! This project is currently in the design phase. Once implementation begins, we'll provide:
+We welcome contributions! This project is in active development. We provide:
 
 - Contributing guidelines
-- Code of conduct
 - Development setup instructions
 - Issue templates
 - Pull request templates
@@ -455,7 +506,7 @@ We welcome contributions! This project is currently in the design phase. Once im
 
 ## 📜 License
 
-MIT License (Planned)
+MIT License
 
 ---
 
@@ -486,9 +537,9 @@ Inspired by:
 
 ## 📈 Project Status
 
-**Current Phase**: Design & Planning  
-**Next Milestone**: Begin Phase 1 implementation  
-**Expected Launch**: Week 20 (approximately 5 months from start)
+**Current Phase**: Active Development  
+**Next Milestone**: Complete visual editor + studio polish  
+**Expected Launch**: TBD
 
 ---