dao-ai 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

dao_ai/providers/databricks.py

@@ -327,7 +327,7 @@ class DatabricksProvider(ServiceProvider):
                 raise FileNotFoundError(f"Code path does not exist: {path}")
 
         model_root_path: Path = Path(dao_ai.__file__).parent
-        model_path: Path = model_root_path / "agent_as_code.py"
+        model_path: Path = model_root_path / "apps" / "model_serving.py"
 
         pip_requirements: Sequence[str] = config.app.pip_requirements
 
@@ -558,6 +558,16 @@ class DatabricksProvider(ServiceProvider):
 
         logger.info("Using workspace source path", source_path=source_path)
 
+        # Get or create experiment for this app (for tracing and tracking)
+        from mlflow.entities import Experiment
+
+        experiment: Experiment = self.get_or_create_experiment(config)
+        logger.info(
+            "Using MLflow experiment for app",
+            experiment_name=experiment.name,
+            experiment_id=experiment.experiment_id,
+        )
+
         # Upload the configuration file to the workspace
         source_config_path: str | None = config.source_config_path
         if source_config_path:
@@ -596,22 +606,19 @@ class DatabricksProvider(ServiceProvider):
                 "model_config.yaml exists in the app source directory."
             )
 
-        # Generate and upload app.yaml
-        # Use pip to install dao-ai and run the app server
-        app_yaml_content: str = """command:
-  - /bin/bash
-  - -c
-  - |
-    pip install dao-ai && python -m dao_ai.app_server
-
-env:
-  - name: MLFLOW_TRACKING_URI
-    value: "databricks"
-  - name: MLFLOW_REGISTRY_URI
-    value: "databricks-uc"
-  - name: DAO_AI_CONFIG_PATH
-    value: "model_config.yaml"
-"""
+        # Generate and upload app.yaml with dynamically discovered resources
+        from dao_ai.apps.resources import generate_app_yaml
+
+        app_yaml_content: str = generate_app_yaml(
+            config,
+            command=[
+                "/bin/bash",
+                "-c",
+                "pip install dao-ai && python -m dao_ai.apps.server",
+            ],
+            include_resources=True,
+        )
+
         app_yaml_path: str = f"{source_path}/app.yaml"
         self.w.workspace.upload(
             path=app_yaml_path,
@@ -619,7 +626,29 @@ env:
             format=ImportFormat.AUTO,
             overwrite=True,
         )
-        logger.info("app.yaml uploaded", path=app_yaml_path)
+        logger.info("app.yaml with resources uploaded", path=app_yaml_path)
+
+        # Generate SDK resources from the config (including experiment)
+        from dao_ai.apps.resources import (
+            generate_sdk_resources,
+            generate_user_api_scopes,
+        )
+
+        sdk_resources = generate_sdk_resources(config, experiment_id=experiment.experiment_id)
+        if sdk_resources:
+            logger.info(
+                "Discovered app resources from config",
+                resource_count=len(sdk_resources),
+                resources=[r.name for r in sdk_resources],
+            )
+
+        # Generate user API scopes for on-behalf-of-user resources
+        user_api_scopes = generate_user_api_scopes(config)
+        if user_api_scopes:
+            logger.info(
+                "Discovered user API scopes for OBO resources",
+                scopes=user_api_scopes,
+            )
 
         # Check if app exists
         app_exists: bool = False
@@ -630,20 +659,33 @@ env:
         except NotFound:
             logger.debug("Creating new app", app_name=app_name)
 
-        # Create or get the app
+        # Create or update the app with resources and user_api_scopes
         if not app_exists:
             logger.info("Creating Databricks App", app_name=app_name)
             app_spec = App(
                 name=app_name,
                 description=config.app.description or f"DAO AI Agent: {app_name}",
+                resources=sdk_resources if sdk_resources else None,
+                user_api_scopes=user_api_scopes if user_api_scopes else None,
             )
             app: App = self.w.apps.create_and_wait(app=app_spec)
             logger.info("App created", app_name=app.name, app_url=app.url)
         else:
             app = existing_app
+            # Update resources and scopes on existing app
+            if sdk_resources or user_api_scopes:
+                logger.info("Updating app resources and scopes", app_name=app_name)
+                updated_app = App(
+                    name=app_name,
+                    description=config.app.description or app.description,
+                    resources=sdk_resources if sdk_resources else None,
+                    user_api_scopes=user_api_scopes if user_api_scopes else None,
+                )
+                app = self.w.apps.update(name=app_name, app=updated_app)
+                logger.info("App resources and scopes updated", app_name=app_name)
 
         # Deploy the app with source code
-        # The app will use the dao_ai.app_server module as the entry point
+        # The app will use the dao_ai.apps.server module as the entry point
         logger.info("Deploying app", app_name=app_name)
 
         # Create deployment configuration

dao_ai/tools/mcp.py

@@ -261,12 +261,12 @@ def _extract_text_content(result: CallToolResult) -> str:
     return "\n".join(text_parts)
 
 
-def _fetch_tools_from_server(function: McpFunctionModel) -> list[Tool]:
+async def _afetch_tools_from_server(function: McpFunctionModel) -> list[Tool]:
     """
-    Fetch raw MCP tools from the server.
+    Async version: Fetch raw MCP tools from the server.
 
-    This is the core async operation that connects to the MCP server
-    and retrieves the list of available tools.
+    This is the primary async implementation that handles the actual MCP connection
+    and tool listing. It's used by both alist_mcp_tools() and acreate_mcp_tools().
 
     Args:
         function: The MCP function model configuration.
@@ -280,14 +280,10 @@ def _fetch_tools_from_server(function: McpFunctionModel) -> list[Tool]:
     connection_config = _build_connection_config(function)
     client = MultiServerMCPClient({"mcp_function": connection_config})
 
-    async def _list_tools_async() -> list[Tool]:
-        """Async helper to list tools from MCP server."""
+    try:
         async with client.session("mcp_function") as session:
             result = await session.list_tools()
             return result.tools if hasattr(result, "tools") else list(result)
-
-    try:
-        return asyncio.run(_list_tools_async())
     except Exception as e:
         if function.connection:
             logger.error(
@@ -312,57 +308,48 @@ def _fetch_tools_from_server(function: McpFunctionModel) -> list[Tool]:
             ) from e
 
 
-def list_mcp_tools(
-    function: McpFunctionModel,
-    apply_filters: bool = True,
-) -> list[MCPToolInfo]:
+def _fetch_tools_from_server(function: McpFunctionModel) -> list[Tool]:
     """
-    List available tools from an MCP server.
-
-    This function connects to an MCP server and returns information about
-    all available tools. It's designed for:
-    - Tool discovery and exploration
-    - UI-based tool selection (e.g., in DAO AI Builder)
-    - Debugging and validation of MCP configurations
+    Sync wrapper: Fetch raw MCP tools from the server.
 
-    The returned MCPToolInfo objects contain all information needed to
-    display tools in a UI and allow users to select which tools to use.
+    For async contexts, use _afetch_tools_from_server() directly.
 
     Args:
-        function: The MCP function model configuration containing:
-            - Connection details (url, connection, headers, etc.)
-            - Optional filtering (include_tools, exclude_tools)
-        apply_filters: Whether to apply include_tools/exclude_tools filters.
-            Set to False to get the complete list of available tools
-            regardless of filter configuration. Default True.
+        function: The MCP function model configuration.
 
     Returns:
-        List of MCPToolInfo objects describing available tools.
-        Each contains name, description, and input_schema.
+        List of raw MCP Tool objects from the server.
 
     Raises:
         RuntimeError: If connection to MCP server fails.
+    """
+    return asyncio.run(_afetch_tools_from_server(function))
 
-    Example:
-        # List all tools from a DBSQL MCP server
-        from dao_ai.config import McpFunctionModel
-        from dao_ai.tools.mcp import list_mcp_tools
 
-        function = McpFunctionModel(sql=True)
-        tools = list_mcp_tools(function)
+async def alist_mcp_tools(
+    function: McpFunctionModel,
+    apply_filters: bool = True,
+) -> list[MCPToolInfo]:
+    """
+    Async version: List available tools from an MCP server.
+
+    This is the primary async implementation for tool discovery.
+    For sync contexts, use list_mcp_tools() instead.
 
-        for tool in tools:
-            print(f"{tool.name}: {tool.description}")
+    Args:
+        function: The MCP function model configuration.
+        apply_filters: Whether to apply include_tools/exclude_tools filters.
 
-        # Get unfiltered list (ignore include_tools/exclude_tools)
-        all_tools = list_mcp_tools(function, apply_filters=False)
+    Returns:
+        List of MCPToolInfo objects describing available tools.
 
-    Note:
-        For creating executable LangChain tools, use create_mcp_tools() instead.
-        This function is for discovery/display purposes only.
+    Raises:
+        RuntimeError: If connection to MCP server fails.
     """
     mcp_url = function.mcp_url
-    logger.debug("Listing MCP tools", mcp_url=mcp_url, apply_filters=apply_filters)
+    logger.debug(
+        "Listing MCP tools (async)", mcp_url=mcp_url, apply_filters=apply_filters
+    )
 
     # Log connection type
     if function.connection:
@@ -378,8 +365,8 @@ def list_mcp_tools(
             mcp_url=mcp_url,
         )
 
-    # Fetch tools from server
-    mcp_tools: list[Tool] = _fetch_tools_from_server(function)
+    # Fetch tools from server (async)
+    mcp_tools: list[Tool] = await _afetch_tools_from_server(function)
 
     # Log discovered tools
     logger.info(
@@ -433,45 +420,155 @@ def list_mcp_tools(
     return tool_infos
 
 
-def create_mcp_tools(
+def list_mcp_tools(
     function: McpFunctionModel,
-) -> Sequence[RunnableLike]:
+    apply_filters: bool = True,
+) -> list[MCPToolInfo]:
     """
-    Create executable LangChain tools for invoking Databricks MCP functions.
+    Sync wrapper: List available tools from an MCP server.
+
+    For async contexts, use alist_mcp_tools() directly.
+
+    Args:
+        function: The MCP function model configuration.
+        apply_filters: Whether to apply include_tools/exclude_tools filters.
 
-    Supports both direct MCP connections and UC Connection-based MCP access.
-    Uses manual tool wrappers to ensure response format compatibility with
-    Databricks APIs (which reject extra fields in tool results).
+    Returns:
+        List of MCPToolInfo objects describing available tools.
+
+    Raises:
+        RuntimeError: If connection to MCP server fails.
+    """
+    return asyncio.run(alist_mcp_tools(function, apply_filters))
 
-    This function:
-    1. Fetches available tools from the MCP server
-    2. Applies include_tools/exclude_tools filters
-    3. Wraps each tool for LangChain agent execution
 
-    For tool discovery without creating executable tools, use list_mcp_tools().
+async def acreate_mcp_tools(
+    function: McpFunctionModel,
+) -> Sequence[RunnableLike]:
+    """
+    Async version: Create executable LangChain tools for invoking Databricks MCP functions.
 
-    Based on: https://docs.databricks.com/aws/en/generative-ai/mcp/external-mcp
+    This is the primary async implementation. For sync contexts, use create_mcp_tools().
 
     Args:
-        function: The MCP function model configuration containing:
-            - Connection details (url, connection, headers, etc.)
-            - Optional filtering (include_tools, exclude_tools)
+        function: The MCP function model configuration.
 
     Returns:
         A sequence of LangChain tools that can be used by agents.
 
     Raises:
         RuntimeError: If connection to MCP server fails.
+    """
+    mcp_url = function.mcp_url
+    logger.debug("Creating MCP tools (async)", mcp_url=mcp_url)
+
+    # Fetch tools from server (async)
+    mcp_tools: list[Tool] = await _afetch_tools_from_server(function)
+
+    # Log discovered tools
+    logger.info(
+        "Discovered MCP tools from server",
+        tools_count=len(mcp_tools),
+        tool_names=[t.name for t in mcp_tools],
+        mcp_url=mcp_url,
+    )
+
+    # Apply filtering if configured
+    if function.include_tools or function.exclude_tools:
+        original_count = len(mcp_tools)
+        mcp_tools = [
+            tool
+            for tool in mcp_tools
+            if _should_include_tool(
+                tool.name,
+                function.include_tools,
+                function.exclude_tools,
+            )
+        ]
+        filtered_count = original_count - len(mcp_tools)
+
+        logger.info(
+            "Filtered MCP tools",
+            original_count=original_count,
+            filtered_count=filtered_count,
+            final_count=len(mcp_tools),
+            include_patterns=function.include_tools,
+            exclude_patterns=function.exclude_tools,
+        )
+
+    # Log final tool list
+    for mcp_tool in mcp_tools:
+        logger.debug(
+            "MCP tool available",
+            tool_name=mcp_tool.name,
+            tool_description=(
+                mcp_tool.description[:100] if mcp_tool.description else None
+            ),
+        )
+
+    def _create_tool_wrapper(mcp_tool: Tool) -> RunnableLike:
+        """
+        Create a LangChain tool wrapper for an MCP tool.
+        """
+
+        @create_tool(
+            mcp_tool.name,
+            description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
+            args_schema=mcp_tool.inputSchema,
+        )
+        async def tool_wrapper(**kwargs: Any) -> str:
+            """Execute MCP tool with fresh session."""
+            logger.trace("Invoking MCP tool", tool_name=mcp_tool.name, args=kwargs)
+
+            invocation_client = MultiServerMCPClient(
+                {"mcp_function": _build_connection_config(function)}
+            )
+
+            try:
+                async with invocation_client.session("mcp_function") as session:
+                    result: CallToolResult = await session.call_tool(
+                        mcp_tool.name, kwargs
+                    )
+
+                    text_result = _extract_text_content(result)
+
+                    logger.trace(
+                        "MCP tool completed",
+                        tool_name=mcp_tool.name,
+                        result_length=len(text_result),
+                    )
+
+                    return text_result
+
+            except Exception as e:
+                logger.error(
+                    "MCP tool failed",
+                    tool_name=mcp_tool.name,
+                    error=str(e),
+                )
+                raise
+
+        return tool_wrapper
+
+    return [_create_tool_wrapper(tool) for tool in mcp_tools]
 
-    Example:
-        from dao_ai.config import McpFunctionModel
-        from dao_ai.tools.mcp import create_mcp_tools
 
-        function = McpFunctionModel(sql=True)
-        tools = create_mcp_tools(function)
+def create_mcp_tools(
+    function: McpFunctionModel,
+) -> Sequence[RunnableLike]:
+    """
+    Sync wrapper: Create executable LangChain tools for invoking Databricks MCP functions.
 
-        # Use tools in an agent
-        agent = create_agent(model=model, tools=tools)
+    For async contexts, use acreate_mcp_tools() directly.
+
+    Args:
+        function: The MCP function model configuration.
+
+    Returns:
+        A sequence of LangChain tools that can be used by agents.
+
+    Raises:
+        RuntimeError: If connection to MCP server fails.
     """
     mcp_url = function.mcp_url
     logger.debug("Creating MCP tools", mcp_url=mcp_url)

{dao_ai-0.1.9.dist-info → dao_ai-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.1.9
+Version: 0.1.11
 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
@@ -28,7 +28,7 @@ Requires-Python: >=3.11
 Requires-Dist: databricks-agents>=1.9.0
 Requires-Dist: databricks-langchain[memory]>=0.12.1
 Requires-Dist: databricks-mcp>=0.5.0
-Requires-Dist: databricks-sdk[openai]>=0.76.0
+Requires-Dist: databricks-sdk[openai]>=0.77.0
 Requires-Dist: ddgs>=9.10.0
 Requires-Dist: dspy>=2.6.27
 Requires-Dist: flashrank>=0.2.10

{dao_ai-0.1.9.dist-info → dao_ai-0.1.11.dist-info}/RECORD

@@ -1,13 +1,11 @@
 dao_ai/__init__.py,sha256=18P98ExEgUaJ1Byw440Ct1ty59v6nxyWtc5S6Uq2m9Q,1062
-dao_ai/agent_as_code.py,sha256=xIlLDpPVfmDVzLvbdY_V_CrC4Jvj2ItCWJ-NzdrszTo,538
-dao_ai/app_server.py,sha256=QKpl068z-s1gLF67dPW-3fT77i33t_Oab4_ugmxISWs,3010
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
-dao_ai/cli.py,sha256=57Kmmi0zgS92ACBTD-gH5hZzW6rPDkbdkRVlFjX4onQ,48604
-dao_ai/config.py,sha256=t7kXU7XjdMaCZ3G9Hn-O9NDOaTS_LaMXX6s5mdyv3dM,127944
+dao_ai/cli.py,sha256=1Ox8qjLKRlrKu2YXozm0lWoeZnDCouECeZSGVPkQgIQ,50923
+dao_ai/config.py,sha256=9G_JiPbr_ihUCaqYPvnMbzLKtyppXTjraQfVOxnqeBA,129323
 dao_ai/graph.py,sha256=1-uQlo7iXZQTT3uU8aYu0N5rnhw5_g_2YLwVsAs6M-U,1119
 dao_ai/logging.py,sha256=lYy4BmucCHvwW7aI3YQkQXKJtMvtTnPDu9Hnd7_O4oc,1556
 dao_ai/messages.py,sha256=4ZBzO4iFdktGSLrmhHzFjzMIt2tpaL-aQLHOQJysGnY,6959
-dao_ai/models.py,sha256=AwzwTRTNZF-UOh59HsuXEgFk_YH6q6M-mERNDe64Z8k,81783
+dao_ai/models.py,sha256=NaHj91Gra4M8thlKX1DSufLqtJfZSZ55lm1H1dJL_O8,77320
 dao_ai/nodes.py,sha256=7W6Ek6Uk9-pKa-H06nVCwuDllCrgX02IYy3rHtuL0aM,10777
 dao_ai/optimization.py,sha256=phK6t4wYmWPObCjGUBHdZzsaFXGhQOjhAek2bAEfwXo,22971
 dao_ai/prompts.py,sha256=4cz5bZ7cOzrjyQ8hMp-K4evK6cVYrkGrAGdUl8-KDEM,2784
@@ -15,6 +13,11 @@ dao_ai/state.py,sha256=ifDTAC7epdowk3Z1CP3Xqw4uH2dIxQEVF3C747dA8yI,6436
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/utils.py,sha256=_Urd7Nj2VzrgPKf3NS4E6vt0lWRhEUddBqWN9BksqeE,11543
 dao_ai/vector_search.py,sha256=8d3xROg9zSIYNXjRRl6rSexsJTlufjRl5Fy1ZA8daKA,4019
+dao_ai/apps/__init__.py,sha256=RLuhZf4gQ4pemwKDz1183aXib8UfaRhwfKvRx68GRlM,661
+dao_ai/apps/handlers.py,sha256=NN81uDV2hy83zT-kY36mxyBgCQIHBJApX4bnUceGB8k,2614
+dao_ai/apps/model_serving.py,sha256=XLt3_0pGSRceMK6YtOrND9Jnh7mKLPCtwjVDLIaptQU,847
+dao_ai/apps/resources.py,sha256=kAXqYx-Xwba1SaltPZIAtB2xoIHxH98Q41b8YGPLfI0,38029
+dao_ai/apps/server.py,sha256=D3R3J1svtpxnpDjoM-oxg66dMDI8USgiQHPRvRHc7oQ,1276
 dao_ai/genie/__init__.py,sha256=vdEyGhrt6L8GlK75SyYvTnl8QpHKDCJC5hJKLg4DesQ,1063
 dao_ai/genie/core.py,sha256=HPKbocvhnnw_PkQwfoq5bpgQmL9lZyyS6_goTJL8yiY,1073
 dao_ai/genie/cache/__init__.py,sha256=JfgCJl1NYQ1aZvZ4kly4T6uQK6ZCJ6PX_htuq7nJF50,1203
@@ -28,7 +31,7 @@ dao_ai/memory/__init__.py,sha256=Us3wFehvug_h83m-UJ7OXdq2qZ0e9nHBQE7m5RwoAd8,559
 dao_ai/memory/base.py,sha256=99nfr2UZJ4jmfTL_KrqUlRSCoRxzkZyWyx5WqeUoMdQ,338
 dao_ai/memory/core.py,sha256=38H-JLIyUrRDIECLvpXK3iJlWG35X97E-DTo_4c3Jzc,6317
 dao_ai/memory/databricks.py,sha256=SM6nwLjhSRJO4hLc3GUuht5YydYtTi3BAOae6jPwTm4,14377
-dao_ai/memory/postgres.py,sha256=q9IIAGs0wuaV-3rUIn4dtzOxbkCCoB-yv1Rtod7ohjI,16467
+dao_ai/memory/postgres.py,sha256=DeLmexSzz91eXEJN5zW4YJigLCby8j9qNAZleumaVHU,17481
 dao_ai/middleware/__init__.py,sha256=Qy8wbvjXF7TrUzi3tWziOwxqsrUcT1rzE3UWd3x5CrU,5108
 dao_ai/middleware/assertions.py,sha256=C1K-TnNZfBEwWouioHCt6c48i1ux9QKfQaX6AzghhgE,27408
 dao_ai/middleware/base.py,sha256=uG2tpdnjL5xY5jCKvb_m3UTBtl4ZC6fJQUkDsQvV8S4,1279
@@ -50,13 +53,13 @@ dao_ai/orchestration/supervisor.py,sha256=alKMEEo9G5LhdpMvTVdAMel234cZj5_MguWl4w
 dao_ai/orchestration/swarm.py,sha256=8tp1eGmsQqqWpaDcjPoJckddPWohZdmmN0RGRJ_xzOA,9198
 dao_ai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/providers/base.py,sha256=cJGo3UjUTPgS91dv38ePOHwQQtYhIa84ebb167CBXjk,2111
-dao_ai/providers/databricks.py,sha256=X_VjzZogwiSlNpPBWP0iMCCXAvfFDRlbC4AZCHleb2A,68608
+dao_ai/providers/databricks.py,sha256=EZokRfbScW5K2h8EOCQ95XjoXt981ySslQk0d0DJmeI,70687
 dao_ai/tools/__init__.py,sha256=NfRpAKds_taHbx6gzLPWgtPXve-YpwzkoOAUflwxceM,1734
 dao_ai/tools/agent.py,sha256=plIWALywRjaDSnot13nYehBsrHRpBUpsVZakoGeajOE,1858
 dao_ai/tools/core.py,sha256=bRIN3BZhRQX8-Kpu3HPomliodyskCqjxynQmYbk6Vjs,3783
 dao_ai/tools/email.py,sha256=A3TsCoQgJR7UUWR0g45OPRGDpVoYwctFs1MOZMTt_d4,7389
 dao_ai/tools/genie.py,sha256=4e_5MeAe7kDzHbYeXuNPFbY5z8ci3ouj8l5254CZ2lA,8874
-dao_ai/tools/mcp.py,sha256=ZNalYo2atZECatZjMT8w4mHEsaUZJQ_fsCjia7px1nc,18689
+dao_ai/tools/mcp.py,sha256=tfn-sdKwfNY31RsDFlafdGyN4XlKGfniXG_mO-Meh4E,21030
 dao_ai/tools/memory.py,sha256=lwObKimAand22Nq3Y63tsv-AXQ5SXUigN9PqRjoWKes,1836
 dao_ai/tools/python.py,sha256=jWFnZPni2sCdtd8D1CqXnZIPHnWkdK27bCJnBXpzhvo,1879
 dao_ai/tools/search.py,sha256=cJ3D9FKr1GAR6xz55dLtRkjtQsI0WRueGt9TPDFpOxc,433
@@ -65,8 +68,8 @@ dao_ai/tools/sql.py,sha256=tKd1gjpLuKdQDyfmyYYtMiNRHDW6MGRbdEVaeqyB8Ok,7632
 dao_ai/tools/time.py,sha256=tufJniwivq29y0LIffbgeBTIDE6VgrLpmVf8Qr90qjw,9224
 dao_ai/tools/unity_catalog.py,sha256=AjQfW7bvV8NurqDLIyntYRv2eJuTwNdbvex1L5CRjOk,15534
 dao_ai/tools/vector_search.py,sha256=oe2uBwl2TfeJIXPpwiS6Rmz7wcHczSxNyqS9P3hE6co,14542
-dao_ai-0.1.9.dist-info/METADATA,sha256=_cVhNKdywyci5ZyrmMfkF9CiWveo4kdoj9OlaM_w-cg,16697
-dao_ai-0.1.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dao_ai-0.1.9.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.1.9.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.1.9.dist-info/RECORD,,
+dao_ai-0.1.11.dist-info/METADATA,sha256=uSlkpK84xgQlBOkLAzdOCycWxUC1ovzrrrU_uCVMOd0,16698
+dao_ai-0.1.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.1.11.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.1.11.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.1.11.dist-info/RECORD,,

dao_ai/agent_as_code.py

@@ -1,22 +0,0 @@
-import mlflow
-from mlflow.models import ModelConfig
-from mlflow.pyfunc import ResponsesAgent
-
-from dao_ai.config import AppConfig
-from dao_ai.logging import configure_logging
-
-mlflow.set_registry_uri("databricks-uc")
-mlflow.set_tracking_uri("databricks")
-
-mlflow.langchain.autolog()
-
-model_config: ModelConfig = ModelConfig()
-config: AppConfig = AppConfig(**model_config.to_dict())
-
-log_level: str = config.app.log_level
-
-configure_logging(level=log_level)
-
-app: ResponsesAgent = config.as_responses_agent()
-
-mlflow.models.set_model(app)