dao-ai 0.0.7__tar.gz → 0.0.9__tar.gz

{dao_ai-0.0.7 → dao_ai-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.7
+Version: 0.0.9
 Summary: DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML.
 Project-URL: Homepage, https://github.com/natefleming/dao-ai
 Project-URL: Documentation, https://natefleming.github.io/dao-ai

{dao_ai-0.0.7 → dao_ai-0.0.9}/config/hardware_store/supervisor_postgres.yaml

@@ -962,10 +962,10 @@ app:
           thread_id: "1"
           user_id: my_user_id
           store_num: 87887
-  chat_history: 
-    #max_tokens: 256
-    max_messages_before_summary: 5
-    model: *fast_llm                          # Model for summarization tasks
+  #chat_history: 
+  #  #max_tokens: 256
+  #  max_messages_before_summary: 5
+  #  model: *fast_llm                          # Model for summarization tasks
 
 
 # =============================================================================

{dao_ai-0.0.7 → dao_ai-0.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dao-ai"
-version = "0.0.7"
+version = "0.0.9"
 description = "DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML."
 readme = "README.md"
 license = { text = "MIT" }

{dao_ai-0.0.7 → dao_ai-0.0.9}/src/dao_ai/config.py

@@ -1,5 +1,6 @@
 import atexit
 import os
+import sys
 from abc import ABC, abstractmethod
 from enum import Enum
 from os import PathLike
@@ -13,7 +14,7 @@ from typing import (
     TypeAlias,
     Union,
 )
-
+import importlib
 from databricks.sdk import WorkspaceClient
 from databricks.sdk.credentials_provider import (
     CredentialsStrategy,
@@ -28,6 +29,7 @@ from langchain_core.language_models import LanguageModelLike
 from langchain_core.runnables.base import RunnableLike
 from langchain_openai import ChatOpenAI
 from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.graph.state import CompiledStateGraph
 from langgraph.store.base import BaseStore
 from loguru import logger
 from mlflow.models import ModelConfig
@@ -41,6 +43,7 @@ from mlflow.models.resources import (
     DatabricksUCConnection,
     DatabricksVectorSearchIndex,
 )
+from mlflow.pyfunc import ChatModel
 from pydantic import BaseModel, ConfigDict, Field, field_serializer, model_validator
 
 
@@ -1067,6 +1070,16 @@ class AppModel(BaseModel):
 
         return self
 
+    @model_validator(mode="after")
+    def add_code_paths_to_sys_path(self):
+        for code_path in self.code_paths:
+            parent_path: str = str(Path(code_path).parent)
+            if parent_path not in sys.path:
+                sys.path.insert(0, parent_path)
+                logger.debug(f"Added code path to sys.path: {parent_path}")
+        importlib.invalidate_caches()
+        return self
+
 
 class GuidelineModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
@@ -1320,3 +1333,16 @@ class AppConfig(BaseModel):
         return [
             guardrail for guardrail in self.guardrails.values() if predicate(guardrail)
         ]
+
+    def as_graph(self) -> CompiledStateGraph:
+        from dao_ai.graph import create_dao_ai_graph
+
+        graph: CompiledStateGraph = create_dao_ai_graph(config=self)
+        return graph
+
+    def as_chat_model(self) -> ChatModel:
+        from dao_ai.models import create_agent
+
+        graph: CompiledStateGraph = self.as_graph()
+        app: ChatModel = create_agent(graph)
+        return app

{dao_ai-0.0.7 → dao_ai-0.0.9}/src/dao_ai/models.py

@@ -266,7 +266,7 @@ def _process_config_messages_stream(
 def process_messages_stream(
     app: LanggraphChatModel,
     messages: Sequence[BaseMessage] | Sequence[ChatMessage] | dict[str, Any],
-    custom_inputs: dict[str, Any],
+    custom_inputs: Optional[dict[str, Any]] = None,
 ) -> Generator[ChatCompletionChunk | AIMessageChunk, None, None]:
     """
     Process messages through a ChatAgent in streaming mode.

{dao_ai-0.0.7 → dao_ai-0.0.9}/src/dao_ai/providers/databricks.py

@@ -1,4 +1,5 @@
 import base64
+from importlib.metadata import version
 from pathlib import Path
 from typing import Any, Callable, Final, Sequence
 
@@ -57,7 +58,12 @@ from dao_ai.config import (
 )
 from dao_ai.models import get_latest_model_version
 from dao_ai.providers.base import ServiceProvider
-from dao_ai.utils import get_installed_packages, is_installed, normalize_name
+from dao_ai.utils import (
+    get_installed_packages,
+    is_installed,
+    is_lib_provided,
+    normalize_name,
+)
 from dao_ai.vector_search import endpoint_exists, index_exists
 
 MAX_NUM_INDEXES: Final[int] = 50
@@ -262,10 +268,6 @@ class DatabricksProvider(ServiceProvider):
         )
         logger.debug(f"auth_policy: {auth_policy}")
 
-        pip_requirements: Sequence[str] = (
-            get_installed_packages() + config.app.pip_requirements
-        )
-
         code_paths: list[str] = config.app.code_paths
         for path in code_paths:
             path = Path(path)
@@ -275,10 +277,13 @@ class DatabricksProvider(ServiceProvider):
         model_root_path: Path = Path(dao_ai.__file__).parent
         model_path: Path = model_root_path / "agent_as_code.py"
 
+        pip_requirements: Sequence[str] = config.app.pip_requirements
+
         if is_installed():
-            pip_requirements += [
-                f"dao-ai=={dao_ai.__version__}",
-            ]
+            if not is_lib_provided("dao-ai", pip_requirements):
+                pip_requirements += [
+                    f"dao-ai=={version('dao-ai')}",
+                ]
         else:
             src_path: Path = model_root_path.parent
             directories: Sequence[Path] = [d for d in src_path.iterdir() if d.is_dir()]
@@ -286,6 +291,8 @@ class DatabricksProvider(ServiceProvider):
                 directory: Path
                 code_paths.append(directory.as_posix())
 
+            pip_requirements += get_installed_packages()
+
         logger.debug(f"pip_requirements: {pip_requirements}")
         logger.debug(f"code_paths: {code_paths}")
 

{dao_ai-0.0.7 → dao_ai-0.0.9}/src/dao_ai/utils.py

@@ -11,6 +11,13 @@ from loguru import logger
 import dao_ai
 
 
+def is_lib_provided(lib_name: str, pip_requirements: Sequence[str]) -> bool:
+    return any(
+        re.search(rf"\b{re.escape(lib_name)}\b", requirement)
+        for requirement in pip_requirements
+    )
+
+
 def is_installed():
     current_file = os.path.abspath(dao_ai.__file__)
     site_packages = [os.path.abspath(path) for path in site.getsitepackages()]
@@ -85,6 +92,7 @@ def load_function(function_name: str) -> Callable[..., Any]:
         >>> version = func("my_model")
     """
     logger.debug(f"Loading function: {function_name}")
+        
     try:
         # Split the FQN into module path and function name
         module_path, func_name = function_name.rsplit(".", 1)

{dao_ai-0.0.7 → dao_ai-0.0.9}/tests/dao_ai/test_config.py

@@ -8,6 +8,7 @@ from mlflow.models import ModelConfig
 
 from dao_ai.config import (
     AppConfig,
+    AppModel,
     CompositeVariableModel,
     EnvironmentVariableModel,
     McpFunctionModel,
@@ -378,3 +379,172 @@ def test_mcp_function_model_real_pat_authentication() -> None:
 
     # No Authorization header should be set at creation time (per-invocation auth)
     assert "Authorization" not in mcp_function.headers
+
+
+@pytest.mark.unit
+def test_app_config_initialize_adds_code_paths_to_sys_path(config: AppConfig) -> None:
+    """Test that code_paths are added to sys.path during model creation"""
+    import os
+    import tempfile
+    from pathlib import Path
+
+    # Create temporary directories for testing
+    with (
+        tempfile.TemporaryDirectory() as temp_dir1,
+        tempfile.TemporaryDirectory() as temp_dir2,
+    ):
+        # Store original sys.path
+        original_sys_path = sys.path.copy()
+
+        try:
+            # Create minimal AppModel data with code_paths
+            from dao_ai.config import (
+                AgentModel,
+                LLMModel,
+                OrchestrationModel,
+                RegisteredModelModel,
+                SchemaModel,
+                SupervisorModel,
+            )
+
+            schema = SchemaModel(catalog_name="test", schema_name="test")
+            registered_model = RegisteredModelModel(schema=schema, name="test_model")
+            supervisor = SupervisorModel(model=LLMModel(name="test"))
+            orchestration = OrchestrationModel(supervisor=supervisor)
+            agent = AgentModel(name="test", model=LLMModel(name="test"))
+
+            # Create new AppModel instance with code_paths - this should trigger the validator
+            _ = AppModel(
+                name="test_app",
+                registered_model=registered_model,
+                orchestration=orchestration,
+                agents=[agent],
+                code_paths=[temp_dir1, temp_dir2],
+            )
+
+            # Verify that the parent directories of both paths were added to sys.path immediately
+            # The implementation adds parent directories, not the exact code_paths
+            abs_temp_dir1 = os.path.abspath(temp_dir1)
+            abs_temp_dir2 = os.path.abspath(temp_dir2)
+            parent_dir1 = str(Path(abs_temp_dir1).parent)
+            parent_dir2 = str(Path(abs_temp_dir2).parent)
+
+            assert parent_dir1 in sys.path, (
+                f"Parent of code path {parent_dir1} not found in sys.path"
+            )
+            assert parent_dir2 in sys.path, (
+                f"Parent of code path {parent_dir2} not found in sys.path"
+            )
+
+            # Since both temp dirs have the same parent (system temp dir), only one parent path should be added
+            # Verify the parent directory was added
+            if parent_dir1 == parent_dir2:
+                # Both temp dirs have same parent, so only one entry
+                assert sys.path.count(parent_dir1) >= 1, (
+                    f"Parent directory {parent_dir1} should be added to sys.path"
+                )
+            else:
+                # Different parents, check both
+                assert parent_dir1 in sys.path, f"Parent {parent_dir1} not in sys.path"
+                assert parent_dir2 in sys.path, f"Parent {parent_dir2} not in sys.path"
+
+        finally:
+            # Restore original sys.path
+            sys.path[:] = original_sys_path
+
+
+@pytest.mark.unit
+def test_app_config_initialize_skips_duplicate_code_paths(config: AppConfig) -> None:
+    """Test that duplicate paths are not added to sys.path"""
+    import os
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        abs_temp_dir = os.path.abspath(temp_dir)
+
+        # Add the path to sys.path first
+        original_sys_path = sys.path.copy()
+        sys.path.insert(0, abs_temp_dir)
+
+        try:
+            # Count occurrences before creating model with code_paths
+            count_before = sys.path.count(abs_temp_dir)
+
+            # Create minimal AppModel data with code_paths
+            from dao_ai.config import (
+                AgentModel,
+                LLMModel,
+                OrchestrationModel,
+                RegisteredModelModel,
+                SchemaModel,
+                SupervisorModel,
+            )
+
+            schema = SchemaModel(catalog_name="test", schema_name="test")
+            registered_model = RegisteredModelModel(schema=schema, name="test_model")
+            supervisor = SupervisorModel(model=LLMModel(name="test"))
+            orchestration = OrchestrationModel(supervisor=supervisor)
+            agent = AgentModel(name="test", model=LLMModel(name="test"))
+
+            # Create new AppModel instance with the same path - this should not add a duplicate
+            _ = AppModel(
+                name="test_app",
+                registered_model=registered_model,
+                orchestration=orchestration,
+                agents=[agent],
+                code_paths=[temp_dir],
+            )
+
+            # Count occurrences after creating model with code_paths
+            count_after = sys.path.count(abs_temp_dir)
+
+            # Should not have added a duplicate
+            assert count_after == count_before, "Duplicate path was added to sys.path"
+
+        finally:
+            # Restore original sys.path
+            sys.path[:] = original_sys_path
+
+
+@pytest.mark.unit
+def test_app_config_initialize_with_empty_code_paths(config: AppConfig) -> None:
+    """Test that empty code_paths works correctly"""
+    # Store original sys.path
+    original_sys_path = sys.path.copy()
+
+    try:
+        # Create minimal AppModel data with empty code_paths
+        from dao_ai.config import (
+            AgentModel,
+            LLMModel,
+            OrchestrationModel,
+            RegisteredModelModel,
+            SchemaModel,
+            SupervisorModel,
+        )
+
+        schema = SchemaModel(catalog_name="test", schema_name="test")
+        registered_model = RegisteredModelModel(schema=schema, name="test_model")
+        supervisor = SupervisorModel(model=LLMModel(name="test"))
+        orchestration = OrchestrationModel(supervisor=supervisor)
+        agent = AgentModel(name="test", model=LLMModel(name="test"))
+
+        # Create new AppModel instance with empty code_paths
+        _ = AppModel(
+            name="test_app",
+            registered_model=registered_model,
+            orchestration=orchestration,
+            agents=[agent],
+            code_paths=[],
+        )
+
+        # sys.path should be unchanged
+        # We can't assert exact equality because the assignment might still trigger the validator,
+        # but we can verify no new paths were added
+        assert True, (
+            "Creating AppModel with empty code_paths should complete without errors"
+        )
+
+    finally:
+        # Restore original sys.path
+        sys.path[:] = original_sys_path

{dao_ai-0.0.7 → dao_ai-0.0.9}/tests/dao_ai/test_utils.py

@@ -1,6 +1,6 @@
 import pytest
 
-from dao_ai.utils import load_function
+from dao_ai.utils import is_lib_provided, load_function
 
 
 @pytest.mark.unit
@@ -45,3 +45,17 @@ def test_load_function_no_dot_separator() -> None:
     """Test loading with invalid function name format."""
     with pytest.raises(ValueError):
         load_function("invalid_format")
+
+
+@pytest.mark.unit
+def test_is_lib_provided() -> None:
+    """Test if a library is provided in the pip requirements."""
+    assert is_lib_provided("dao-ai", ["dao-ai", "pandas"]) is True
+    assert is_lib_provided("dao-ai", ["dao-ai>=0.0.1", "pandas"]) is True
+    assert is_lib_provided("dao-ai", ["numpy", "pandas"]) is False
+    assert (
+        is_lib_provided(
+            "dao-ai", ["git+https://github.com/natefleming/dao-ai.git", "numpy"]
+        )
+        is True
+    )