dao-ai 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

dao_ai/agent_as_code.py

@@ -3,7 +3,7 @@ import sys
 import mlflow
 from loguru import logger
 from mlflow.models import ModelConfig
-from mlflow.pyfunc import ChatModel
+from mlflow.pyfunc import ResponsesAgent
 
 from dao_ai.config import AppConfig
 
@@ -17,6 +17,6 @@ log_level: str = config.app.log_level
 logger.remove()
 logger.add(sys.stderr, level=log_level)
 
-app: ChatModel = config.as_chat_model()
+app: ResponsesAgent = config.as_responses_agent()
 
 mlflow.models.set_model(app)

dao_ai/config.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import (
     Any,
     Callable,
+    Iterator,
     Literal,
     Optional,
     Sequence,
@@ -21,6 +22,7 @@ from databricks.sdk.credentials_provider import (
     CredentialsStrategy,
     ModelServingUserCredentials,
 )
+from databricks.sdk.service.catalog import FunctionInfo, TableInfo
 from databricks.vector_search.client import VectorSearchClient
 from databricks.vector_search.index import VectorSearchIndex
 from databricks_langchain import (
@@ -44,8 +46,14 @@ from mlflow.models.resources import (
     DatabricksUCConnection,
     DatabricksVectorSearchIndex,
 )
-from mlflow.pyfunc import ChatModel
-from pydantic import BaseModel, ConfigDict, Field, field_serializer, model_validator
+from mlflow.pyfunc import ChatModel, ResponsesAgent
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_serializer,
+    model_validator,
+)
 
 
 class HasValue(ABC):
@@ -69,7 +77,7 @@ class IsDatabricksResource(ABC):
     on_behalf_of_user: Optional[bool] = False
 
     @abstractmethod
-    def as_resource(self) -> DatabricksResource: ...
+    def as_resources(self) -> Sequence[DatabricksResource]: ...
 
     @property
     @abstractmethod
@@ -235,22 +243,68 @@ class SchemaModel(BaseModel, HasFullName):
 class TableModel(BaseModel, HasFullName, IsDatabricksResource):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
     schema_model: Optional[SchemaModel] = Field(default=None, alias="schema")
-    name: str
+    name: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_name_or_schema_required(self) -> "TableModel":
+        if not self.name and not self.schema_model:
+            raise ValueError(
+                "Either 'name' or 'schema_model' must be provided for TableModel"
+            )
+        return self
 
     @property
     def full_name(self) -> str:
         if self.schema_model:
-            return f"{self.schema_model.catalog_name}.{self.schema_model.schema_name}.{self.name}"
+            name: str = ""
+            if self.name:
+                name = f".{self.name}"
+            return f"{self.schema_model.catalog_name}.{self.schema_model.schema_name}{name}"
         return self.name
 
     @property
     def api_scopes(self) -> Sequence[str]:
         return []
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksTable(
-            table_name=self.full_name, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        resources: list[DatabricksResource] = []
+
+        excluded_suffixes: Sequence[str] = [
+            "_payload",
+            "_assessment_logs",
+            "_request_logs",
+        ]
+        
+        excluded_prefixes: Sequence[str] = [
+            "trace_logs_"
+        ]
+
+        if self.name:
+            resources.append(
+                DatabricksTable(
+                    table_name=self.full_name, on_behalf_of_user=self.on_behalf_of_user
+                )
+            )
+        else:
+            w: WorkspaceClient = self.workspace_client
+            schema_full_name: str = self.schema_model.full_name
+            tables: Iterator[TableInfo] = w.tables.list(
+                catalog_name=self.schema_model.catalog_name,
+                schema_name=self.schema_model.schema_name,
+            )
+            resources.extend(
+                [
+                    DatabricksTable(
+                        table_name=f"{schema_full_name}.{table.name}",
+                        on_behalf_of_user=self.on_behalf_of_user,
+                    )
+                    for table in tables
+                    if not any(table.name.endswith(suffix) for suffix in excluded_suffixes)
+                    and not any(table.name.startswith(prefix) for prefix in excluded_prefixes)
+                ]
+            )
+
+        return resources
 
 
 class LLMModel(BaseModel, IsDatabricksResource):
@@ -266,10 +320,12 @@ class LLMModel(BaseModel, IsDatabricksResource):
             "serving.serving-endpoints",
         ]
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksServingEndpoint(
-            endpoint_name=self.name, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        return [
+            DatabricksServingEndpoint(
+                endpoint_name=self.name, on_behalf_of_user=self.on_behalf_of_user
+            )
+        ]
 
     def as_chat_model(self) -> LanguageModelLike:
         # Retrieve langchain chat client from workspace client to enable OBO
@@ -345,10 +401,12 @@ class IndexModel(BaseModel, HasFullName, IsDatabricksResource):
             return f"{self.schema_model.catalog_name}.{self.schema_model.schema_name}.{self.name}"
         return self.name
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksVectorSearchIndex(
-            index_name=self.full_name, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        return [
+            DatabricksVectorSearchIndex(
+                index_name=self.full_name, on_behalf_of_user=self.on_behalf_of_user
+            )
+        ]
 
 
 class GenieRoomModel(BaseModel, IsDatabricksResource):
@@ -363,10 +421,12 @@ class GenieRoomModel(BaseModel, IsDatabricksResource):
             "dashboards.genie",
         ]
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksGenieSpace(
-            genie_space_id=self.space_id, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        return [
+            DatabricksGenieSpace(
+                genie_space_id=self.space_id, on_behalf_of_user=self.on_behalf_of_user
+            )
+        ]
 
 
 class VolumeModel(BaseModel, HasFullName):
@@ -394,7 +454,7 @@ class VolumePathModel(BaseModel, HasFullName):
     path: Optional[str] = None
 
     @model_validator(mode="after")
-    def validate_path_or_volume(self):
+    def validate_path_or_volume(self) -> "VolumePathModel":
         if not self.volume and not self.path:
             raise ValueError("Either 'volume' or 'path' must be provided")
         return self
@@ -502,8 +562,8 @@ class VectorStoreModel(BaseModel, IsDatabricksResource):
             "serving.serving-endpoints",
         ] + self.index.api_scopes
 
-    def as_resource(self) -> DatabricksResource:
-        return self.index.as_resource()
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        return self.index.as_resources()
 
     def as_index(self, vsc: VectorSearchClient | None = None) -> VectorSearchIndex:
         from dao_ai.providers.base import ServiceProvider
@@ -524,18 +584,52 @@ class VectorStoreModel(BaseModel, IsDatabricksResource):
 class FunctionModel(BaseModel, HasFullName, IsDatabricksResource):
     model_config = ConfigDict()
     schema_model: Optional[SchemaModel] = Field(default=None, alias="schema")
-    name: str
+    name: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_name_or_schema_required(self) -> "FunctionModel":
+        if not self.name and not self.schema_model:
+            raise ValueError(
+                "Either 'name' or 'schema_model' must be provided for FunctionModel"
+            )
+        return self
 
     @property
     def full_name(self) -> str:
         if self.schema_model:
-            return f"{self.schema_model.catalog_name}.{self.schema_model.schema_name}.{self.name}"
+            name: str = ""
+            if self.name:
+                name = f".{self.name}"
+            return f"{self.schema_model.catalog_name}.{self.schema_model.schema_name}{name}"
         return self.name
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksFunction(
-            function_name=self.full_name, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        resources: list[DatabricksResource] = []
+        if self.name:
+            resources.append(
+                DatabricksFunction(
+                    function_name=self.full_name,
+                    on_behalf_of_user=self.on_behalf_of_user,
+                )
+            )
+        else:
+            w: WorkspaceClient = self.workspace_client
+            schema_full_name: str = self.schema_model.full_name
+            functions: Iterator[FunctionInfo] = w.functions.list(
+                catalog_name=self.schema_model.catalog_name,
+                schema_name=self.schema_model.schema_name,
+            )
+            resources.extend(
+                [
+                    DatabricksFunction(
+                        function_name=f"{schema_full_name}.{function.name}",
+                        on_behalf_of_user=self.on_behalf_of_user,
+                    )
+                    for function in functions
+                ]
+            )
+
+        return resources
 
     @property
     def api_scopes(self) -> Sequence[str]:
@@ -556,10 +650,12 @@ class ConnectionModel(BaseModel, HasFullName, IsDatabricksResource):
             "catalog.connections",
         ]
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksUCConnection(
-            connection_name=self.name, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        return [
+            DatabricksUCConnection(
+                connection_name=self.name, on_behalf_of_user=self.on_behalf_of_user
+            )
+        ]
 
 
 class WarehouseModel(BaseModel, IsDatabricksResource):
@@ -575,10 +671,12 @@ class WarehouseModel(BaseModel, IsDatabricksResource):
             "sql.statement-execution",
         ]
 
-    def as_resource(self) -> DatabricksResource:
-        return DatabricksSQLWarehouse(
-            warehouse_id=self.warehouse_id, on_behalf_of_user=self.on_behalf_of_user
-        )
+    def as_resources(self) -> Sequence[DatabricksResource]:
+        return [
+            DatabricksSQLWarehouse(
+                warehouse_id=self.warehouse_id, on_behalf_of_user=self.on_behalf_of_user
+            )
+        ]
 
 
 class DatabaseModel(BaseModel):
@@ -1034,9 +1132,37 @@ class Message(BaseModel):
 
 class ChatPayload(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
-    messages: list[Message]
+    input: Optional[list[Message]] = None
+    messages: Optional[list[Message]] = None
     custom_inputs: dict
 
+    @model_validator(mode="after")
+    def validate_mutual_exclusion_and_alias(self) -> "ChatPayload":
+        """Handle dual field support with automatic aliasing."""
+        # If both fields are provided and they're the same, that's okay (redundant but valid)
+        if self.input is not None and self.messages is not None:
+            # Allow if they're identical (redundant specification)
+            if self.input == self.messages:
+                return self
+            # If they're different, prefer input and copy to messages
+            else:
+                self.messages = self.input
+                return self
+
+        # If neither field is provided, that's an error
+        if self.input is None and self.messages is None:
+            raise ValueError("Must specify either 'input' or 'messages' field.")
+
+        # Create alias: copy messages to input if input is None
+        if self.input is None and self.messages is not None:
+            self.input = self.messages
+
+        # Create alias: copy input to messages if messages is None
+        elif self.messages is None and self.input is not None:
+            self.messages = self.input
+
+        return self
+
 
 class ChatHistoryModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
@@ -1374,3 +1500,10 @@ class AppConfig(BaseModel):
         graph: CompiledStateGraph = self.as_graph()
         app: ChatModel = create_agent(graph)
         return app
+
+    def as_responses_agent(self) -> ResponsesAgent:
+        from dao_ai.models import create_responses_agent
+
+        graph: CompiledStateGraph = self.as_graph()
+        app: ResponsesAgent = create_responses_agent(graph)
+        return app

dao_ai/graph.py

@@ -221,7 +221,7 @@ def _create_swarm_graph(config: AppConfig) -> CompiledStateGraph:
 
     return swarm_node
 
-    #return workflow.compile(checkpointer=checkpointer, store=store)
+    # return workflow.compile(checkpointer=checkpointer, store=store)
 
 
 def create_dao_ai_graph(config: AppConfig) -> CompiledStateGraph:

dao_ai/messages.py

@@ -11,6 +11,9 @@ from langchain_core.messages import (
 )
 from langchain_core.messages.modifier import RemoveMessage
 from mlflow.types.llm import ChatMessage
+from mlflow.types.responses import (
+    ResponsesAgentRequest,
+)
 
 
 def remove_messages(
@@ -96,6 +99,10 @@ def has_mlflow_messages(messages: ChatMessage | Sequence[ChatMessage]) -> bool:
     return any(isinstance(m, ChatMessage) for m in messages)
 
 
+def has_mlflow_responses_messages(messages: ResponsesAgentRequest) -> bool:
+    return isinstance(messages, ResponsesAgentRequest)
+
+
 def has_image(messages: BaseMessage | Sequence[BaseMessage]) -> bool:
     """
     Check if a message contains an image.

dao_ai/models.py

@@ -1,13 +1,14 @@
 import uuid
 from os import PathLike
 from pathlib import Path
-from typing import Any, Generator, Optional, Sequence
+from typing import Any, Generator, Optional, Sequence, Union
 
 from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage
 from langgraph.graph.state import CompiledStateGraph
 from loguru import logger
 from mlflow import MlflowClient
-from mlflow.pyfunc import ChatAgent, ChatModel
+from mlflow.pyfunc import ChatAgent, ChatModel, ResponsesAgent
+from mlflow.types.agent import ChatContext
 from mlflow.types.llm import (
     ChatChoice,
     ChatChoiceDelta,
@@ -17,8 +18,21 @@ from mlflow.types.llm import (
     ChatMessage,
     ChatParams,
 )
+from mlflow.types.responses import (
+    ResponsesAgentRequest,
+    ResponsesAgentResponse,
+    ResponsesAgentStreamEvent,
+)
+from mlflow.types.responses_helpers import (
+    Message,
+    ResponseInputTextParam,
+)
 
-from dao_ai.messages import has_langchain_messages, has_mlflow_messages
+from dao_ai.messages import (
+    has_langchain_messages,
+    has_mlflow_messages,
+    has_mlflow_responses_messages,
+)
 from dao_ai.state import Context
 
 
@@ -65,9 +79,19 @@ class LanggraphChatModel(ChatModel):
         context: Context = self._convert_to_context(params)
         custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
 
-        response: dict[str, Sequence[BaseMessage]] = self.graph.invoke(
-            request, context=context, config=custom_inputs
+        # Use async ainvoke internally for parallel execution
+        import asyncio
+
+        async def _async_invoke():
+            return await self.graph.ainvoke(
+                request, context=context, config=custom_inputs
+            )
+
+        loop = asyncio.get_event_loop()
+        response: dict[str, Sequence[BaseMessage]] = loop.run_until_complete(
+            _async_invoke()
         )
+
         logger.trace(f"response: {response}")
 
         last_message: BaseMessage = response["messages"][-1]
@@ -114,33 +138,51 @@ class LanggraphChatModel(ChatModel):
         context: Context = self._convert_to_context(params)
         custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
 
-        for nodes, stream_mode, messages_batch in self.graph.stream(
-            request,
-            context=context,
-            config=custom_inputs,
-            stream_mode=["messages", "custom"],
-            subgraphs=True,
-        ):
-            nodes: tuple[str, ...]
-            stream_mode: str
-            messages_batch: Sequence[BaseMessage]
-            logger.trace(
-                f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {messages_batch}"
-            )
-            for message in messages_batch:
-                if (
-                    isinstance(
-                        message,
-                        (
-                            AIMessageChunk,
-                            AIMessage,
-                        ),
-                    )
-                    and message.content
-                    and "summarization" not in nodes
-                ):
-                    content = message.content
-                    yield self._create_chat_completion_chunk(content)
+        # Use async astream internally for parallel execution
+        import asyncio
+
+        async def _async_stream():
+            async for nodes, stream_mode, messages_batch in self.graph.astream(
+                request,
+                context=context,
+                config=custom_inputs,
+                stream_mode=["messages", "custom"],
+                subgraphs=True,
+            ):
+                nodes: tuple[str, ...]
+                stream_mode: str
+                messages_batch: Sequence[BaseMessage]
+                logger.trace(
+                    f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {messages_batch}"
+                )
+                for message in messages_batch:
+                    if (
+                        isinstance(
+                            message,
+                            (
+                                AIMessageChunk,
+                                AIMessage,
+                            ),
+                        )
+                        and message.content
+                        and "summarization" not in nodes
+                    ):
+                        content = message.content
+                        yield self._create_chat_completion_chunk(content)
+
+        # Convert async generator to sync generator
+        loop = asyncio.get_event_loop()
+        async_gen = _async_stream()
+
+        try:
+            while True:
+                try:
+                    item = loop.run_until_complete(async_gen.__anext__())
+                    yield item
+                except StopAsyncIteration:
+                    break
+        finally:
+            loop.run_until_complete(async_gen.aclose())
 
     def _create_chat_completion_chunk(self, content: str) -> ChatCompletionChunk:
         return ChatCompletionChunk(
@@ -157,6 +199,232 @@ class LanggraphChatModel(ChatModel):
         return [m.to_dict() for m in messages]
 
 
+class LanggraphResponsesAgent(ResponsesAgent):
+    """
+    ResponsesAgent that delegates requests to a LangGraph CompiledStateGraph.
+
+    This is the modern replacement for LanggraphChatModel, providing better
+    support for streaming, tool calling, and async execution.
+    """
+
+    def __init__(self, graph: CompiledStateGraph) -> None:
+        self.graph = graph
+
+    def predict(self, request: ResponsesAgentRequest) -> ResponsesAgentResponse:
+        """
+        Process a ResponsesAgentRequest and return a ResponsesAgentResponse.
+        """
+        logger.debug(f"ResponsesAgent request: {request}")
+
+        # Convert ResponsesAgent input to LangChain messages
+        messages = self._convert_request_to_langchain_messages(request)
+
+        # Prepare context
+        context: Context = self._convert_request_to_context(request)
+        custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
+
+        # Use async ainvoke internally for parallel execution
+        import asyncio
+
+        async def _async_invoke():
+            return await self.graph.ainvoke(
+                {"messages": messages}, context=context, config=custom_inputs
+            )
+
+        loop = asyncio.get_event_loop()
+        response: dict[str, Sequence[BaseMessage]] = loop.run_until_complete(
+            _async_invoke()
+        )
+
+        # Convert response to ResponsesAgent format
+        last_message: BaseMessage = response["messages"][-1]
+
+        output_item = self.create_text_output_item(
+            text=last_message.content, id=f"msg_{uuid.uuid4().hex[:8]}"
+        )
+
+        return ResponsesAgentResponse(
+            output=[output_item], custom_outputs=request.custom_inputs
+        )
+
+    def predict_stream(
+        self, request: ResponsesAgentRequest
+    ) -> Generator[ResponsesAgentStreamEvent, None, None]:
+        """
+        Process a ResponsesAgentRequest and yield ResponsesAgentStreamEvent objects.
+        """
+        logger.debug(f"ResponsesAgent stream request: {request}")
+
+        # Convert ResponsesAgent input to LangChain messages
+        messages: list[BaseMessage] = self._convert_request_to_langchain_messages(
+            request
+        )
+
+        # Prepare context
+        context: Context = self._convert_request_to_context(request)
+        custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
+
+        # Use async astream internally for parallel execution
+        import asyncio
+
+        async def _async_stream():
+            item_id = f"msg_{uuid.uuid4().hex[:8]}"
+            accumulated_content = ""
+
+            async for nodes, stream_mode, messages_batch in self.graph.astream(
+                {"messages": messages},
+                context=context,
+                config=custom_inputs,
+                stream_mode=["messages", "custom"],
+                subgraphs=True,
+            ):
+                nodes: tuple[str, ...]
+                stream_mode: str
+                messages_batch: Sequence[BaseMessage]
+
+                for message in messages_batch:
+                    if (
+                        isinstance(
+                            message,
+                            (
+                                AIMessageChunk,
+                                AIMessage,
+                            ),
+                        )
+                        and message.content
+                        and "summarization" not in nodes
+                    ):
+                        content = message.content
+                        accumulated_content += content
+
+                        # Yield streaming delta
+                        yield ResponsesAgentStreamEvent(
+                            **self.create_text_delta(delta=content, item_id=item_id)
+                        )
+
+            # Yield final output item
+            yield ResponsesAgentStreamEvent(
+                type="response.output_item.done",
+                item=self.create_text_output_item(text=accumulated_content, id=item_id),
+                custom_outputs=request.custom_inputs,
+            )
+
+        # Convert async generator to sync generator
+        loop = asyncio.get_event_loop()
+        async_gen = _async_stream()
+
+        try:
+            while True:
+                try:
+                    item = loop.run_until_complete(async_gen.__anext__())
+                    yield item
+                except StopAsyncIteration:
+                    break
+        finally:
+            loop.run_until_complete(async_gen.aclose())
+
+    def _extract_text_from_content(
+        self,
+        content: Union[str, list[Union[ResponseInputTextParam, str, dict[str, Any]]]],
+    ) -> str:
+        """Extract text content from various MLflow content formats.
+
+        MLflow ResponsesAgent supports multiple content formats:
+        - str: Simple text content
+        - list[ResponseInputTextParam]: Structured text objects with .text attribute
+        - list[dict]: Dictionaries with "text" key
+        - Mixed lists of the above types
+
+        This method normalizes all formats to a single concatenated string.
+
+        Args:
+            content: The content to extract text from
+
+        Returns:
+            Concatenated text string from all content items
+        """
+        if isinstance(content, str):
+            return content
+        elif isinstance(content, list):
+            text_parts = []
+            for content_item in content:
+                if isinstance(content_item, ResponseInputTextParam):
+                    text_parts.append(content_item.text)
+                elif isinstance(content_item, str):
+                    text_parts.append(content_item)
+                elif isinstance(content_item, dict) and "text" in content_item:
+                    text_parts.append(content_item["text"])
+            return "".join(text_parts)
+        else:
+            # Fallback for unknown types - try to extract text attribute
+            return getattr(content, "text", str(content))
+
+    def _convert_request_to_langchain_messages(
+        self, request: ResponsesAgentRequest
+    ) -> list[dict[str, Any]]:
+        """Convert ResponsesAgent input to LangChain message format."""
+        messages = []
+
+        for input_item in request.input:
+            if isinstance(input_item, Message):
+                # Handle MLflow Message objects
+                content = self._extract_text_from_content(input_item.content)
+                messages.append({"role": input_item.role, "content": content})
+            elif isinstance(input_item, dict):
+                # Handle dict format
+                if "role" in input_item and "content" in input_item:
+                    content = self._extract_text_from_content(input_item["content"])
+                    messages.append({"role": input_item["role"], "content": content})
+            else:
+                # Fallback for other object types with role/content attributes
+                role = getattr(input_item, "role", "user")
+                content = self._extract_text_from_content(
+                    getattr(input_item, "content", "")
+                )
+                messages.append({"role": role, "content": content})
+
+        return messages
+
+    def _convert_request_to_context(self, request: ResponsesAgentRequest) -> Context:
+        """Convert ResponsesAgent context to internal Context."""
+
+        logger.debug(f"request.context: {request.context}")
+        logger.debug(f"request.custom_inputs: {request.custom_inputs}")
+
+        configurable: dict[str, Any] = {}
+
+        # Process context values first (lower priority)
+        # Use strong typing with forward-declared type hints instead of hasattr checks
+        chat_context: Optional[ChatContext] = request.context
+        if chat_context is not None:
+            conversation_id: Optional[str] = chat_context.conversation_id
+            user_id: Optional[str] = chat_context.user_id
+
+            if conversation_id is not None:
+                configurable["conversation_id"] = conversation_id
+                configurable["thread_id"] = conversation_id
+
+            if user_id is not None:
+                configurable["user_id"] = user_id
+
+        # Process custom_inputs after context so they can override context values (higher priority)
+        if request.custom_inputs:
+            if "configurable" in request.custom_inputs:
+                configurable.update(request.custom_inputs.pop("configurable"))
+
+            configurable.update(request.custom_inputs)
+
+        if "user_id" in configurable:
+            configurable["user_id"] = configurable["user_id"].replace(".", "_")
+
+        if "thread_id" not in configurable:
+            configurable["thread_id"] = str(uuid.uuid4())
+
+        logger.debug(f"Creating context from: {configurable}")
+
+        return Context(**configurable)
+
+
 def create_agent(graph: CompiledStateGraph) -> ChatAgent:
     """
     Create an MLflow-compatible ChatAgent from a LangGraph state machine.
@@ -173,14 +441,39 @@ def create_agent(graph: CompiledStateGraph) -> ChatAgent:
     return LanggraphChatModel(graph)
 
 
+def create_responses_agent(graph: CompiledStateGraph) -> ResponsesAgent:
+    """
+    Create an MLflow-compatible ResponsesAgent from a LangGraph state machine.
+
+    Factory function that wraps a compiled LangGraph in the LanggraphResponsesAgent
+    class to make it deployable through MLflow.
+
+    Args:
+        graph: A compiled LangGraph state machine
+
+    Returns:
+        An MLflow-compatible ResponsesAgent instance
+    """
+    return LanggraphResponsesAgent(graph)
+
+
 def _process_langchain_messages(
     app: LanggraphChatModel | CompiledStateGraph,
     messages: Sequence[BaseMessage],
     custom_inputs: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any] | Any:
+    """Process LangChain messages using async LangGraph calls internally."""
+    import asyncio
+
     if isinstance(app, LanggraphChatModel):
         app = app.graph
-    return app.invoke({"messages": messages}, config=custom_inputs)
+
+    # Use async ainvoke internally for parallel execution
+    async def _async_invoke():
+        return await app.ainvoke({"messages": messages}, config=custom_inputs)
+
+    loop = asyncio.get_event_loop()
+    return loop.run_until_complete(_async_invoke())
 
 
 def _process_langchain_messages_stream(
@@ -188,6 +481,9 @@ def _process_langchain_messages_stream(
     messages: Sequence[BaseMessage],
     custom_inputs: Optional[dict[str, Any]] = None,
 ) -> Generator[AIMessageChunk, None, None]:
+    """Process LangChain messages in streaming mode using async LangGraph calls internally."""
+    import asyncio
+
     if isinstance(app, LanggraphChatModel):
         app = app.graph
 
@@ -196,32 +492,48 @@ def _process_langchain_messages_stream(
     custom_inputs = custom_inputs.get("configurable", custom_inputs or {})
     context: Context = Context(**custom_inputs)
 
-    for nodes, stream_mode, messages in app.stream(
-        {"messages": messages},
-        context=context,
-        config=custom_inputs,
-        stream_mode=["messages", "custom"],
-        subgraphs=True,
-    ):
-        nodes: tuple[str, ...]
-        stream_mode: str
-        messages: Sequence[BaseMessage]
-        logger.trace(
-            f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {messages}"
-        )
-        for message in messages:
-            if (
-                isinstance(
-                    message,
-                    (
-                        AIMessageChunk,
-                        AIMessage,
-                    ),
-                )
-                and message.content
-                and "summarization" not in nodes
-            ):
-                yield message
+    # Use async astream internally for parallel execution
+    async def _async_stream():
+        async for nodes, stream_mode, stream_messages in app.astream(
+            {"messages": messages},
+            context=context,
+            config=custom_inputs,
+            stream_mode=["messages", "custom"],
+            subgraphs=True,
+        ):
+            nodes: tuple[str, ...]
+            stream_mode: str
+            stream_messages: Sequence[BaseMessage]
+            logger.trace(
+                f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {stream_messages}"
+            )
+            for message in stream_messages:
+                if (
+                    isinstance(
+                        message,
+                        (
+                            AIMessageChunk,
+                            AIMessage,
+                        ),
+                    )
+                    and message.content
+                    and "summarization" not in nodes
+                ):
+                    yield message
+
+    # Convert async generator to sync generator
+    loop = asyncio.get_event_loop()
+    async_gen = _async_stream()
+
+    try:
+        while True:
+            try:
+                item = loop.run_until_complete(async_gen.__anext__())
+                yield item
+            except StopAsyncIteration:
+                break
+    finally:
+        loop.run_until_complete(async_gen.aclose())
 
 
 def _process_mlflow_messages(
@@ -232,6 +544,14 @@ def _process_mlflow_messages(
     return app.predict(None, messages, custom_inputs)
 
 
+def _process_mlflow_response_messages(
+    app: ResponsesAgent,
+    messages: ResponsesAgentRequest,
+) -> ResponsesAgentResponse:
+    """Process MLflow ResponsesAgent request in batch mode."""
+    return app.predict(messages)
+
+
 def _process_mlflow_messages_stream(
     app: ChatModel,
     messages: Sequence[ChatMessage],
@@ -242,37 +562,73 @@ def _process_mlflow_messages_stream(
         yield event
 
 
+def _process_mlflow_response_messages_stream(
+    app: ResponsesAgent,
+    messages: ResponsesAgentRequest,
+) -> Generator[ResponsesAgentStreamEvent, None, None]:
+    """Process MLflow ResponsesAgent request in streaming mode."""
+    for event in app.predict_stream(messages):
+        event: ResponsesAgentStreamEvent
+        yield event
+
+
 def _process_config_messages(
-    app: ChatModel,
+    app: LanggraphChatModel | LanggraphResponsesAgent,
     messages: dict[str, Any],
     custom_inputs: Optional[dict[str, Any]] = None,
-) -> ChatCompletionResponse:
-    messages: Sequence[ChatMessage] = [ChatMessage(**m) for m in messages]
-    params: ChatParams = ChatParams(**{"custom_inputs": custom_inputs})
-
-    return _process_mlflow_messages(app, messages, params)
+) -> ChatCompletionResponse | ResponsesAgentResponse:
+    if isinstance(app, LanggraphChatModel):
+        messages: Sequence[ChatMessage] = [ChatMessage(**m) for m in messages]
+        params: ChatParams = ChatParams(**{"custom_inputs": custom_inputs})
+        return _process_mlflow_messages(app, messages, params)
+
+    elif isinstance(app, LanggraphResponsesAgent):
+        input_messages: list[Message] = [Message(**m) for m in messages]
+        request = ResponsesAgentRequest(
+            input=input_messages, custom_inputs=custom_inputs
+        )
+        return _process_mlflow_response_messages(app, request)
 
 
 def _process_config_messages_stream(
-    app: ChatModel, messages: dict[str, Any], custom_inputs: dict[str, Any]
-) -> Generator[ChatCompletionChunk, None, None]:
-    messages: Sequence[ChatMessage] = [ChatMessage(**m) for m in messages]
-    params: ChatParams = ChatParams(**{"custom_inputs": custom_inputs})
+    app: LanggraphChatModel | LanggraphResponsesAgent,
+    messages: dict[str, Any],
+    custom_inputs: dict[str, Any],
+) -> Generator[ChatCompletionChunk | ResponsesAgentStreamEvent, None, None]:
+    if isinstance(app, LanggraphChatModel):
+        messages: Sequence[ChatMessage] = [ChatMessage(**m) for m in messages]
+        params: ChatParams = ChatParams(**{"custom_inputs": custom_inputs})
 
-    for event in _process_mlflow_messages_stream(app, messages, custom_inputs=params):
-        yield event
+        for event in _process_mlflow_messages_stream(
+            app, messages, custom_inputs=params
+        ):
+            yield event
+
+    elif isinstance(app, LanggraphResponsesAgent):
+        input_messages: list[Message] = [Message(**m) for m in messages]
+        request = ResponsesAgentRequest(
+            input=input_messages, custom_inputs=custom_inputs
+        )
+
+        for event in _process_mlflow_response_messages_stream(app, request):
+            yield event
 
 
 def process_messages_stream(
-    app: LanggraphChatModel,
-    messages: Sequence[BaseMessage] | Sequence[ChatMessage] | dict[str, Any],
+    app: LanggraphChatModel | LanggraphResponsesAgent,
+    messages: Sequence[BaseMessage]
+    | Sequence[ChatMessage]
+    | ResponsesAgentRequest
+    | dict[str, Any],
     custom_inputs: Optional[dict[str, Any]] = None,
-) -> Generator[ChatCompletionChunk | AIMessageChunk, None, None]:
+) -> Generator[
+    ChatCompletionChunk | ResponsesAgentStreamEvent | AIMessageChunk, None, None
+]:
     """
     Process messages through a ChatAgent in streaming mode.
 
     Utility function that normalizes message input formats and
-    streams the agent's responses as they're generated.
+    streams the agent's responses as they're generated using async LangGraph calls internally.
 
     Args:
         app: The ChatAgent to process messages with
@@ -282,7 +638,10 @@ def process_messages_stream(
         Individual message chunks from the streaming response
     """
 
-    if has_mlflow_messages(messages):
+    if has_mlflow_responses_messages(messages):
+        for event in _process_mlflow_response_messages_stream(app, messages):
+            yield event
+    elif has_mlflow_messages(messages):
         for event in _process_mlflow_messages_stream(app, messages, custom_inputs):
             yield event
     elif has_langchain_messages(messages):
@@ -294,15 +653,18 @@ def process_messages_stream(
 
 
 def process_messages(
-    app: LanggraphChatModel,
-    messages: Sequence[BaseMessage] | Sequence[ChatMessage] | dict[str, Any],
+    app: LanggraphChatModel | LanggraphResponsesAgent,
+    messages: Sequence[BaseMessage]
+    | Sequence[ChatMessage]
+    | ResponsesAgentRequest
+    | dict[str, Any],
     custom_inputs: Optional[dict[str, Any]] = None,
-) -> ChatCompletionResponse | dict[str, Any] | Any:
+) -> ChatCompletionResponse | ResponsesAgentResponse | dict[str, Any] | Any:
     """
     Process messages through a ChatAgent in batch mode.
 
     Utility function that normalizes message input formats and
-    returns the complete response from the agent.
+    returns the complete response from the agent using async LangGraph calls internally.
 
     Args:
         app: The ChatAgent to process messages with
@@ -312,7 +674,9 @@ def process_messages(
         Complete response from the agent
     """
 
-    if has_mlflow_messages(messages):
+    if has_mlflow_responses_messages(messages):
+        return _process_mlflow_response_messages(app, messages)
+    elif has_mlflow_messages(messages):
         return _process_mlflow_messages(app, messages, custom_inputs)
     elif has_langchain_messages(messages):
         return _process_langchain_messages(app, messages, custom_inputs)

dao_ai/nodes.py

@@ -69,7 +69,7 @@ def summarization_node(app_model: AppModel) -> RunnableLike:
 
 
 def call_agent_with_summarized_messages(agent: CompiledStateGraph) -> RunnableLike:
-    def call_agent(state: SharedState, runtime: Runtime[Context]) -> SharedState:
+    async def call_agent(state: SharedState, runtime: Runtime[Context]) -> SharedState:
         logger.debug(f"Calling agent {agent.name} with summarized messages")
 
         # Get the summarized messages from the summarization node
@@ -81,7 +81,9 @@ def call_agent_with_summarized_messages(agent: CompiledStateGraph) -> RunnableLi
             "messages": messages,
         }
 
-        response: dict[str, Any] = agent.invoke(input=input, context=runtime.context)
+        response: dict[str, Any] = await agent.ainvoke(
+            input=input, context=runtime.context
+        )
         response_messages = response.get("messages", [])
         logger.debug(f"Agent returned {len(response_messages)} messages")
 
@@ -193,7 +195,9 @@ def message_hook_node(config: AppConfig) -> RunnableLike:
     message_hooks: Sequence[Callable[..., Any]] = create_hooks(config.app.message_hooks)
 
     @mlflow.trace()
-    def message_hook(state: IncomingState, runtime: Runtime[Context]) -> SharedState:
+    async def message_hook(
+        state: IncomingState, runtime: Runtime[Context]
+    ) -> SharedState:
         logger.debug("Running message validation")
         response: dict[str, Any] = {"is_valid": True, "message_error": None}
 

dao_ai/providers/databricks.py

@@ -235,12 +235,16 @@ class DatabricksProvider(ServiceProvider):
             + connections
         )
 
-        # all_resources: Sequence[DatabricksResource] = [
-        #     r.as_resource() for r in resources
-        # ]
+        # Flatten all resources from all models into a single list
+        all_resources: list[DatabricksResource] = []
+        for r in resources:
+            all_resources.extend(r.as_resources())
 
         system_resources: Sequence[DatabricksResource] = [
-            r.as_resource() for r in resources if not r.on_behalf_of_user
+            resource
+            for r in resources
+            for resource in r.as_resources()
+            if not r.on_behalf_of_user
         ]
         logger.debug(f"system_resources: {[r.name for r in system_resources]}")
 

dao_ai/tools/agent.py

@@ -40,16 +40,16 @@ def create_agent_endpoint_tool(
 
     doc: str = description + "\n" + doc_signature
 
-    def agent_endpoint(prompt: str) -> AIMessage:
+    async def agent_endpoint(prompt: str) -> AIMessage:
         model: LanguageModelLike = llm.as_chat_model()
         messages: Sequence[BaseMessage] = [HumanMessage(content=prompt)]
-        response: AIMessage = model.invoke(messages)
+        response: AIMessage = await model.ainvoke(messages)
         return response
 
     name: str = name if name else agent_endpoint.__name__
 
     structured_tool: StructuredTool = StructuredTool.from_function(
-        func=agent_endpoint, name=name, description=doc, parse_docstring=False
+        coroutine=agent_endpoint, name=name, description=doc, parse_docstring=False
     )
 
     return structured_tool

dao_ai/tools/genie.py

@@ -62,14 +62,16 @@ def create_genie_tool(
 
     doc: str = description + "\n" + doc_signature
 
-    def genie_tool(question: str) -> GenieResponse:
+    async def genie_tool(question: str) -> GenieResponse:
+        # Use sync API for now since Genie doesn't support async yet
+        # Can be easily updated to await when Genie gets async support
         response: GenieResponse = genie.ask_question(question)
         return response
 
     name: str = name if name else genie_tool.__name__
 
     structured_tool: StructuredTool = StructuredTool.from_function(
-        func=genie_tool, name=name, description=doc, parse_docstring=False
+        coroutine=genie_tool, name=name, description=doc, parse_docstring=False
     )
 
     return structured_tool

dao_ai/tools/human_in_the_loop.py

@@ -50,7 +50,7 @@ def add_human_in_the_loop(
     logger.debug(f"Wrapping tool {tool} with human-in-the-loop functionality")
 
     @create_tool(tool.name, description=tool.description, args_schema=tool.args_schema)
-    def call_tool_with_interrupt(config: RunnableConfig, **tool_input) -> Any:
+    async def call_tool_with_interrupt(config: RunnableConfig, **tool_input) -> Any:
         logger.debug(f"call_tool_with_interrupt: {tool.name} with input: {tool_input}")
         request: HumanInterrupt = {
             "action_request": {
@@ -66,10 +66,10 @@ def add_human_in_the_loop(
         logger.debug(f"Human interrupt response: {response}")
 
         if response["type"] == "accept":
-            tool_response = tool.invoke(tool_input, config=config)
+            tool_response = await tool.ainvoke(tool_input, config=config)
         elif response["type"] == "edit":
             tool_input = response["args"]["args"]
-            tool_response = tool.invoke(tool_input, config=config)
+            tool_response = await tool.ainvoke(tool_input, config=config)
         elif response["type"] == "response":
             user_feedback = response["args"]
             tool_response = user_feedback

dao_ai/tools/mcp.py

@@ -77,6 +77,8 @@ def create_mcp_tools(
             logger.error(f"Failed to list MCP tools: {e}")
             return []
 
+    # Note: This still needs to run sync during tool creation/registration
+    # The actual tool execution will be async
     try:
         mcp_tools: list | ListToolsResult = asyncio.run(_list_mcp_tools())
         if isinstance(mcp_tools, ListToolsResult):
@@ -96,22 +98,19 @@ def create_mcp_tools(
             description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
             args_schema=mcp_tool.inputSchema,
         )
-        def tool_wrapper(**kwargs):
+        async def tool_wrapper(**kwargs):
             """Execute MCP tool with fresh session and authentication."""
             logger.debug(f"Invoking MCP tool {mcp_tool.name} with fresh session")
 
-            async def _invoke():
-                connection = _create_fresh_connection()
-                client = MultiServerMCPClient({function.name: connection})
+            connection = _create_fresh_connection()
+            client = MultiServerMCPClient({function.name: connection})
 
-                try:
-                    async with client.session(function.name) as session:
-                        return await session.call_tool(mcp_tool.name, kwargs)
-                except Exception as e:
-                    logger.error(f"MCP tool {mcp_tool.name} failed: {e}")
-                    raise
-
-            return asyncio.run(_invoke())
+            try:
+                async with client.session(function.name) as session:
+                    return await session.call_tool(mcp_tool.name, kwargs)
+            except Exception as e:
+                logger.error(f"MCP tool {mcp_tool.name} failed: {e}")
+                raise
 
         return as_human_in_the_loop(tool_wrapper, function)
 

{dao_ai-0.0.16.dist-info → dao_ai-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.16
+Version: 0.0.18
 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.16.dist-info → dao_ai-0.0.18.dist-info}/RECORD

@@ -1,14 +1,14 @@
 dao_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/agent_as_code.py,sha256=rMWMC0nabtABHPD5H-Yy9ej7QNebLnXfvlZPiwrthoE,457
+dao_ai/agent_as_code.py,sha256=kPSeDz2-1jRaed1TMs4LA3VECoyqe9_Ed2beRLB9gXQ,472
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
 dao_ai/chat_models.py,sha256=uhwwOTeLyHWqoTTgHrs4n5iSyTwe4EQcLKnh3jRxPWI,8626
 dao_ai/cli.py,sha256=Aez2TQW3Q8Ho1IaIkRggt0NevDxAAVPjXkePC5GPJF0,20429
-dao_ai/config.py,sha256=VyHqkW1UMQJ0fzyme1fV_3fi_6wDmKRQeCrx881fDQ4,45173
-dao_ai/graph.py,sha256=8A-qbZAC9BgDitWjxdGFmldKgSHMeoX3z6j3fwmr5Y0,7830
+dao_ai/config.py,sha256=JlYC8N_7UL8VVkdSepiCUnR9NA5OsCVAigLjse7dMFM,49922
+dao_ai/graph.py,sha256=kXaGLGFVekDWqm-AHzti6LmrXnyi99VQ-AdCGuNb_xM,7831
 dao_ai/guardrails.py,sha256=-Qh0f_2Db9t4Nbrrx9FM7tnpqShjMoyxepZ0HByItfU,4027
-dao_ai/messages.py,sha256=tRZQTeb5YFKu8cm1xeaCkKhidq-0tdzncNEzVePvits,6806
-dao_ai/models.py,sha256=wME6hS7w2BTS4SUlhEYuCExMOYStnWk-YWsyatAHYyY,11836
-dao_ai/nodes.py,sha256=nusBk8tBLY4JlkmzObCKwDe5JR11A8XzYcenC-yS43o,8406
+dao_ai/messages.py,sha256=xl_3-WcFqZKCFCiov8sZOPljTdM3gX3fCHhxq-xFg2U,7005
+dao_ai/models.py,sha256=h_xFMK5FHQwPApEAYhvrt69y7ZUljmqThHTjp-yde_o,25368
+dao_ai/nodes.py,sha256=SSuFNTXOdFaKg_aX-yUkQO7fM9wvNGu14lPXKDapU1U,8461
 dao_ai/prompts.py,sha256=vpmIbWs_szXUgNNDs5Gh2LcxKZti5pHDKSfoClUcgX0,1289
 dao_ai/state.py,sha256=GwbMbd1TWZx1T5iQrEOX6_rpxOitlmyeJ8dMr2o_pag,1031
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,19 +22,19 @@ dao_ai/memory/core.py,sha256=K45iCEFbqJCVxMi4m3vmBJi4c6TQ-UtKGzyugDTkPP0,4141
 dao_ai/memory/postgres.py,sha256=YILzA7xtqawPAOLFaGG_i17zW7cQxXTzTD8yd-ipe8k,12480
 dao_ai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/providers/base.py,sha256=-fjKypCOk28h6vioPfMj9YZSw_3Kcbi2nMuAyY7vX9k,1383
-dao_ai/providers/databricks.py,sha256=XRPOqwF5SeA9rPAOWMg2gSMC7lw31BI5VI_4K0KIOqo,27931
+dao_ai/providers/databricks.py,sha256=KLYrLccOA3Uws9nWJcJUZTbMz-MdR_onhlQeztbplCM,28073
 dao_ai/tools/__init__.py,sha256=ye6MHaJY7tUnJ8336YJiLxuZr55zDPNdOw6gm7j5jlc,1103
-dao_ai/tools/agent.py,sha256=_XMz6HtrybpVthhRyStADechF6vXLFyK97i01XTBhtw,1868
+dao_ai/tools/agent.py,sha256=WbQnyziiT12TLMrA7xK0VuOU029tdmUBXbUl-R1VZ0Q,1886
 dao_ai/tools/core.py,sha256=Kei33S8vrmvPOAyrFNekaWmV2jqZ-IPS1QDSvU7RZF0,1984
-dao_ai/tools/genie.py,sha256=yG0Y6FHsYJBdhY7TJoKiUF7XCmCBMsPlbASnZhsUN84,2636
-dao_ai/tools/human_in_the_loop.py,sha256=9HpbFQ9NW6R6eu8eNz2hWPekrB0FFUOJyfa5nUzqqNo,3446
-dao_ai/tools/mcp.py,sha256=rUeodCfGFXSvW-byTW9gsO6QI-p5SZkAP8ZFCFzREY0,4400
+dao_ai/tools/genie.py,sha256=GzV5lfDYKmzW_lSLxAsPaTwnzX6GxQOB1UcLaTDqpfY,2787
+dao_ai/tools/human_in_the_loop.py,sha256=IBmQJmpxkdDxnBNyABc_-dZhhsQlTNTkPyUXgkHKIgY,3466
+dao_ai/tools/mcp.py,sha256=auEt_dwv4J26fr5AgLmwmnAsI894-cyuvkvjItzAUxs,4419
 dao_ai/tools/python.py,sha256=XcQiTMshZyLUTVR5peB3vqsoUoAAy8gol9_pcrhddfI,1831
 dao_ai/tools/time.py,sha256=Y-23qdnNHzwjvnfkWvYsE7PoWS1hfeKy44tA7sCnNac,8759
 dao_ai/tools/unity_catalog.py,sha256=PXfLj2EgyQgaXq4Qq3t25AmTC4KyVCF_-sCtg6enens,1404
 dao_ai/tools/vector_search.py,sha256=EDYQs51zIPaAP0ma1D81wJT77GQ-v-cjb2XrFVWfWdg,2621
-dao_ai-0.0.16.dist-info/METADATA,sha256=D7Bus2E6nvTL3BVMF1sKPViSS-6CZpzqw6qRRwNGxxI,41378
-dao_ai-0.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dao_ai-0.0.16.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.0.16.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.0.16.dist-info/RECORD,,
+dao_ai-0.0.18.dist-info/METADATA,sha256=9lTAXjEqQHxl6dmRMyiqUnYT1Nh_wJpSeJXRG8bGZGg,41378
+dao_ai-0.0.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dao_ai-0.0.18.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.0.18.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.0.18.dist-info/RECORD,,