genxai-framework 0.1.0__py3-none-any.whl → 0.1.2__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/observability/logging.py

@@ -4,7 +4,7 @@ import json
 import logging
 import sys
 from contextvars import ContextVar
-from datetime import datetime
+from datetime import datetime, UTC
 from typing import Any, Dict, Optional
 
 
@@ -250,7 +250,7 @@ class StructuredLogger:
             JSON formatted log string
         """
         log_entry = {
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(UTC).isoformat(),
             "level": level,
             "message": message,
             "context": {**get_log_context(), **self.context},

genxai/security/auth.py

@@ -4,7 +4,7 @@ import secrets
 import hashlib
 import time
 from typing import Optional, List, Dict, Any
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, UTC
 from dataclasses import dataclass
 import sqlite3
 import os
@@ -94,7 +94,7 @@ class APIKeyManager:
         # Calculate expiration
         expires_at = None
         if expires_in_days:
-            expires_at = datetime.utcnow() + timedelta(days=expires_in_days)
+            expires_at = datetime.now(UTC) + timedelta(days=expires_in_days)
         
         # Store in database
         conn = sqlite3.connect(self.db_path)
@@ -103,7 +103,7 @@ class APIKeyManager:
         cursor.execute("""
             INSERT INTO api_keys (key_id, user_id, name, key_hash, created_at, expires_at)
             VALUES (?, ?, ?, ?, ?, ?)
-        """, (key_id, user_id, name, key_hash, datetime.utcnow(), expires_at))
+        """, (key_id, user_id, name, key_hash, datetime.now(UTC), expires_at))
         
         conn.commit()
         conn.close()
@@ -144,14 +144,16 @@ class APIKeyManager:
         # Check expiration
         if expires_at:
             expires_dt = datetime.fromisoformat(expires_at)
-            if datetime.utcnow() > expires_dt:
+            if expires_dt.tzinfo is None:
+                expires_dt = expires_dt.replace(tzinfo=UTC)
+            if datetime.now(UTC) > expires_dt:
                 conn.close()
                 return None
         
         # Update last used
         cursor.execute("""
             UPDATE api_keys SET last_used = ? WHERE key_id = ?
-        """, (datetime.utcnow(), key_id))
+        """, (datetime.now(UTC), key_id))
         
         conn.commit()
         conn.close()
@@ -257,7 +259,9 @@ class APIKeyManager:
         expires_in_days = None
         if expires_at:
             expires_dt = datetime.fromisoformat(expires_at)
-            expires_in_days = (expires_dt - datetime.utcnow()).days
+            if expires_dt.tzinfo is None:
+                expires_dt = expires_dt.replace(tzinfo=UTC)
+            expires_in_days = (expires_dt - datetime.now(UTC)).days
         
         return self.generate_key(user_id, name, expires_in_days)
 

genxai/security/cost_control.py

@@ -2,7 +2,7 @@
 
 import sqlite3
 from typing import Dict, Any, Optional
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, UTC
 from dataclasses import dataclass
 import os
 
@@ -106,7 +106,7 @@ class TokenUsageTracker:
             INSERT INTO token_usage 
             (user_id, provider, model, prompt_tokens, completion_tokens, cost, timestamp)
             VALUES (?, ?, ?, ?, ?, ?, ?)
-        """, (user_id, provider, model, prompt_tokens, completion_tokens, cost, datetime.utcnow()))
+        """, (user_id, provider, model, prompt_tokens, completion_tokens, cost, datetime.now(UTC)))
         
         conn.commit()
         conn.close()
@@ -126,7 +126,7 @@ class TokenUsageTracker:
             Usage statistics
         """
         # Calculate time range
-        now = datetime.utcnow()
+        now = datetime.now(UTC)
         if period == "day":
             start_time = now - timedelta(days=1)
         elif period == "week":
@@ -223,7 +223,7 @@ class BudgetManager:
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
-        now = datetime.utcnow()
+        now = datetime.now(UTC)
         
         cursor.execute("""
             INSERT OR REPLACE INTO budgets (user_id, amount, period, created_at, updated_at)
@@ -447,7 +447,7 @@ class CostAlertManager:
             # Check if we already sent alert recently (within 1 hour)
             if last_alert:
                 last_alert_time = datetime.fromisoformat(last_alert)
-                if datetime.utcnow() - last_alert_time < timedelta(hours=1):
+                if datetime.now(UTC) - last_alert_time < timedelta(hours=1):
                     conn.close()
                     return
             
@@ -462,7 +462,7 @@ class CostAlertManager:
             # Update last alert time
             cursor.execute("""
                 UPDATE cost_alerts SET last_alert = ? WHERE user_id = ?
-            """, (datetime.utcnow(), user_id))
+            """, (datetime.now(UTC), user_id))
             
             conn.commit()
         

genxai/security/jwt.py

@@ -2,7 +2,7 @@
 
 import jwt
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, UTC
 from typing import Dict, Any, Optional
 from dataclasses import dataclass
 
@@ -50,7 +50,7 @@ class JWTManager:
         Returns:
             JWT token string
         """
-        now = datetime.utcnow()
+        now = datetime.now(UTC)
         exp = now + timedelta(seconds=expires_in)
         
         payload = {

genxai/security/pii.py

@@ -3,7 +3,7 @@
 import re
 from typing import List, Dict, Any, Optional
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, UTC
 
 
 # PII patterns
@@ -254,7 +254,7 @@ class PIIAuditLogger:
             context: Additional context
         """
         log_entry = {
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(UTC).isoformat(),
             "user_id": user_id,
             "pii_type": pii_type,
             "action": action,

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/triggers/schedule.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import datetime, UTC
 from typing import Any, Dict, Optional
 import logging
 
@@ -52,7 +52,7 @@ class ScheduleTrigger(BaseTrigger):
             trigger = IntervalTrigger(seconds=self.interval_seconds)
 
         async def _emit_wrapper() -> None:
-            await self.emit(payload={"scheduled_at": datetime.utcnow().isoformat(), **self.payload})
+            await self.emit(payload={"scheduled_at": datetime.now(UTC).isoformat(), **self.payload})
 
         scheduler.add_job(_emit_wrapper, trigger=trigger)
         scheduler.start()

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,