dao-ai 0.0.33__tar.gz → 0.0.35__tar.gz

{dao_ai-0.0.33 → dao_ai-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.33
+Version: 0.0.35
 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.33 → dao_ai-0.0.35}/environment.yaml

@@ -59,7 +59,7 @@ dependencies:
   - flask-cors==6.0.1
   - gunicorn==23.0.0
   # Search and tools
-  - duckduckgo-search==8.0.4
+  - ddgs==9.9.3
   - flashrank==0.2.8
   - litellm==1.75.9
   # Utilities

{dao_ai-0.0.33 → dao_ai-0.0.35}/notebooks/05_deploy_agent.py

@@ -53,7 +53,7 @@ pip_requirements: Sequence[str] = [
     f"databricks-connect=={get_distribution('databricks-connect').version}",
     f"databricks-langchain=={version('databricks-langchain')}",
     f"databricks-sdk=={version('databricks-sdk')}",
-    f"duckduckgo-search=={version('duckduckgo-search')}",
+    f"ddgs=={version('ddgs')}",
     f"langchain=={version('langchain')}",
     f"langchain-mcp-adapters=={version('langchain-mcp-adapters')}",
     f"langgraph=={version('langgraph')}",

{dao_ai-0.0.33 → dao_ai-0.0.35}/notebooks/99_scratchpad.py

@@ -63,7 +63,7 @@ pip_requirements: Sequence[str] = (
   f"python-dotenv=={version('python-dotenv')}",
   f"loguru=={version('loguru')}",
   f"openevals=={version('openevals')}",
-  f"duckduckgo-search=={version('duckduckgo-search')}",
+  f"ddgs=={version('ddgs')}",
   f"faker=={version('faker')}",
 )
 

{dao_ai-0.0.33 → dao_ai-0.0.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dao-ai"
-version = "0.0.33"
+version = "0.0.35"
 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.33 → dao_ai-0.0.35}/requirements.txt

@@ -55,7 +55,6 @@ grandalf==0.8
 graphene==3.4.3
 graphql-core==3.2.6
 graphql-relay==3.2.0
-greenlet==3.2.3
 grpcio==1.73.0
 grpcio-status==1.71.0
 gunicorn==23.0.0

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/config.py

@@ -236,9 +236,21 @@ class Privilege(str, Enum):
 
 class PermissionModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
-    principals: list[str] = Field(default_factory=list)
+    principals: list[ServicePrincipalModel | str] = Field(default_factory=list)
     privileges: list[Privilege]
 
+    @model_validator(mode="after")
+    def resolve_principals(self) -> Self:
+        """Resolve ServicePrincipalModel objects to their client_id."""
+        resolved: list[str] = []
+        for principal in self.principals:
+            if isinstance(principal, ServicePrincipalModel):
+                resolved.append(value_of(principal.client_id))
+            else:
+                resolved.append(principal)
+        self.principals = resolved
+        return self
+
 
 class SchemaModel(BaseModel, HasFullName):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
@@ -1180,21 +1192,26 @@ class McpFunctionModel(BaseFunctionModel, HasFullName):
         Otherwise, falls back to the default Databricks host.
 
         Returns:
-            str: The workspace host URL without trailing slash
+            str: The workspace host URL with https:// scheme and without trailing slash
         """
-        from dao_ai.utils import get_default_databricks_host
+        from dao_ai.utils import get_default_databricks_host, normalize_host
 
         # Try to get workspace_host from config
         workspace_host: str | None = (
-            value_of(self.workspace_host) if self.workspace_host else None
+            normalize_host(value_of(self.workspace_host))
+            if self.workspace_host
+            else None
         )
 
         # If no workspace_host in config, get it from workspace client
         if not workspace_host:
             # Use connection's workspace client if available
             if self.connection:
-                workspace_host = self.connection.workspace_client.config.host
+                workspace_host = normalize_host(
+                    self.connection.workspace_client.config.host
+                )
             else:
+                # get_default_databricks_host already normalizes the host
                 workspace_host = get_default_databricks_host()
 
         if not workspace_host:
@@ -1581,9 +1598,21 @@ class Entitlement(str, Enum):
 
 class AppPermissionModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
-    principals: list[str] = Field(default_factory=list)
+    principals: list[ServicePrincipalModel | str] = Field(default_factory=list)
     entitlements: list[Entitlement]
 
+    @model_validator(mode="after")
+    def resolve_principals(self) -> Self:
+        """Resolve ServicePrincipalModel objects to their client_id."""
+        resolved: list[str] = []
+        for principal in self.principals:
+            if isinstance(principal, ServicePrincipalModel):
+                resolved.append(value_of(principal.client_id))
+            else:
+                resolved.append(principal)
+        self.principals = resolved
+        return self
+
 
 class LogLevel(str, Enum):
     TRACE = "TRACE"

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/models.py

@@ -331,13 +331,23 @@ class LanggraphResponsesAgent(ResponsesAgent):
         context: Context = self._convert_request_to_context(request)
         custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
 
+        # Build the graph input state, including genie_conversation_ids if provided
+        graph_input: dict[str, Any] = {"messages": messages}
+        if request.custom_inputs and "genie_conversation_ids" in request.custom_inputs:
+            graph_input["genie_conversation_ids"] = request.custom_inputs[
+                "genie_conversation_ids"
+            ]
+            logger.debug(
+                f"Including genie_conversation_ids in graph input: {graph_input['genie_conversation_ids']}"
+            )
+
         # Use async ainvoke internally for parallel execution
         import asyncio
 
         async def _async_invoke():
             try:
                 return await self.graph.ainvoke(
-                    {"messages": messages}, context=context, config=custom_inputs
+                    graph_input, context=context, config=custom_inputs
                 )
             except Exception as e:
                 logger.error(f"Error in graph.ainvoke: {e}")
@@ -399,6 +409,16 @@ class LanggraphResponsesAgent(ResponsesAgent):
         context: Context = self._convert_request_to_context(request)
         custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
 
+        # Build the graph input state, including genie_conversation_ids if provided
+        graph_input: dict[str, Any] = {"messages": messages}
+        if request.custom_inputs and "genie_conversation_ids" in request.custom_inputs:
+            graph_input["genie_conversation_ids"] = request.custom_inputs[
+                "genie_conversation_ids"
+            ]
+            logger.debug(
+                f"Including genie_conversation_ids in graph input: {graph_input['genie_conversation_ids']}"
+            )
+
         # Use async astream internally for parallel execution
         import asyncio
 
@@ -408,7 +428,7 @@ class LanggraphResponsesAgent(ResponsesAgent):
 
             try:
                 async for nodes, stream_mode, messages_batch in self.graph.astream(
-                    {"messages": messages},
+                    graph_input,
                     context=context,
                     config=custom_inputs,
                     stream_mode=["messages", "custom"],

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/providers/databricks.py

@@ -73,6 +73,7 @@ from dao_ai.utils import (
     get_installed_packages,
     is_installed,
     is_lib_provided,
+    normalize_host,
     normalize_name,
 )
 from dao_ai.vector_search import endpoint_exists, index_exists
@@ -94,15 +95,18 @@ def _workspace_client(
     Create a WorkspaceClient instance with the provided parameters.
     If no parameters are provided, it will use the default configuration.
     """
-    if client_id and client_secret and workspace_host:
+    # Normalize the workspace host to ensure it has https:// scheme
+    normalized_host = normalize_host(workspace_host)
+
+    if client_id and client_secret and normalized_host:
         return WorkspaceClient(
-            host=workspace_host,
+            host=normalized_host,
             client_id=client_id,
             client_secret=client_secret,
             auth_type="oauth-m2m",
         )
     elif pat:
-        return WorkspaceClient(host=workspace_host, token=pat, auth_type="pat")
+        return WorkspaceClient(host=normalized_host, token=pat, auth_type="pat")
     else:
         return WorkspaceClient()
 
@@ -117,15 +121,18 @@ def _vector_search_client(
     Create a VectorSearchClient instance with the provided parameters.
     If no parameters are provided, it will use the default configuration.
     """
-    if client_id and client_secret and workspace_host:
+    # Normalize the workspace host to ensure it has https:// scheme
+    normalized_host = normalize_host(workspace_host)
+
+    if client_id and client_secret and normalized_host:
         return VectorSearchClient(
-            workspace_url=workspace_host,
+            workspace_url=normalized_host,
             service_principal_client_id=client_id,
             service_principal_client_secret=client_secret,
         )
-    elif pat and workspace_host:
+    elif pat and normalized_host:
         return VectorSearchClient(
-            workspace_url=workspace_host,
+            workspace_url=normalized_host,
             personal_access_token=pat,
         )
     else:
@@ -1151,7 +1158,7 @@ class DatabricksProvider(ServiceProvider):
         If an explicit version or alias is specified in the prompt_model, uses that directly.
         Otherwise, tries to load prompts in this order:
         1. champion alias
-        2. latest version (max version number from search_prompt_versions)
+        2. latest alias
         3. default alias
         4. Register default_template if provided
 
@@ -1166,7 +1173,6 @@ class DatabricksProvider(ServiceProvider):
         """
 
         prompt_name: str = prompt_model.full_name
-        mlflow_client: MlflowClient = MlflowClient()
 
         # If explicit version or alias is specified, use it directly
         if prompt_model.version or prompt_model.alias:
@@ -1197,19 +1203,13 @@ class DatabricksProvider(ServiceProvider):
         except Exception as e:
             logger.debug(f"Champion alias not found for '{prompt_name}': {e}")
 
-        # 2. Try to get latest version by finding the max version number
+        # 2. Try latest alias
         try:
-            versions = mlflow_client.search_prompt_versions(
-                prompt_name, max_results=100
-            )
-            if versions:
-                latest = max(versions, key=lambda v: int(v.version))
-                logger.info(
-                    f"Loaded prompt '{prompt_name}' version {latest.version} (latest by max version)"
-                )
-                return latest
+            prompt_version = load_prompt(f"prompts:/{prompt_name}@latest")
+            logger.info(f"Loaded prompt '{prompt_name}' from latest alias")
+            return prompt_version
         except Exception as e:
-            logger.debug(f"Failed to find latest version for '{prompt_name}': {e}")
+            logger.debug(f"Latest alias not found for '{prompt_name}': {e}")
 
         # 3. Try default alias
         try:
@@ -1225,7 +1225,7 @@ class DatabricksProvider(ServiceProvider):
                 f"No existing prompt found for '{prompt_name}', "
                 "attempting to register default_template"
             )
-            return self._sync_default_template_to_registry(
+            return self._register_default_template(
                 prompt_name, prompt_model.default_template, prompt_model.description
             )
 
@@ -1235,49 +1235,17 @@ class DatabricksProvider(ServiceProvider):
             "and no default_template provided"
         )
 
-    def _sync_default_template_to_registry(
+    def _register_default_template(
         self, prompt_name: str, default_template: str, description: str | None = None
     ) -> PromptVersion:
-        """Get the best available prompt version, or register default_template if possible.
-
-        Tries to load prompts in order: champion → latest (max version) → default.
-        If none found and we have write permissions, registers the default_template.
-        If registration fails (e.g., in Model Serving), logs the error and raises.
-        """
-        mlflow_client: MlflowClient = MlflowClient()
-
-        # Try to find an existing prompt version in priority order
-        # 1. Try champion alias
-        try:
-            champion = mlflow.genai.load_prompt(f"prompts:/{prompt_name}@champion")
-            logger.info(f"Loaded prompt '{prompt_name}' from champion alias")
-            return champion
-        except Exception as e:
-            logger.debug(f"Champion alias not found for '{prompt_name}': {e}")
+        """Register default_template as a new prompt version.
 
-        # 2. Try to get the latest version by finding the max version number
-        try:
-            versions = mlflow_client.search_prompt_versions(
-                prompt_name, max_results=100
-            )
-            if versions:
-                latest = max(versions, key=lambda v: int(v.version))
-                logger.info(
-                    f"Loaded prompt '{prompt_name}' version {latest.version} (latest by max version)"
-                )
-                return latest
-        except Exception as e:
-            logger.debug(f"Failed to search versions for '{prompt_name}': {e}")
+        Called when no existing prompt version is found (champion, latest, default all failed).
+        Registers the template and sets both 'default' and 'champion' aliases.
 
-        # 3. Try default alias
-        try:
-            default = mlflow.genai.load_prompt(f"prompts:/{prompt_name}@default")
-            logger.info(f"Loaded prompt '{prompt_name}' from default alias")
-            return default
-        except Exception as e:
-            logger.debug(f"Default alias not found for '{prompt_name}': {e}")
-
-        # No existing prompt found - try to register if we have a template
+        If registration fails (e.g., in Model Serving with restricted permissions),
+        logs the error and raises.
+        """
         logger.info(
             f"No existing prompt found for '{prompt_name}', attempting to register default_template"
         )

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/tools/genie.py

@@ -5,8 +5,9 @@ from typing import Annotated, Any, Callable
 
 import pandas as pd
 from databricks_ai_bridge.genie import Genie, GenieResponse
+from langchain.tools import tool
 from langchain_core.messages import ToolMessage
-from langchain_core.tools import InjectedToolCallId, tool
+from langchain_core.tools import InjectedToolCallId
 from langgraph.prebuilt import InjectedState
 from langgraph.types import Command
 from loguru import logger
@@ -43,7 +44,7 @@ def create_genie_tool(
     genie_room: GenieRoomModel | dict[str, Any],
     name: str | None = None,
     description: str | None = None,
-    persist_conversation: bool = False,
+    persist_conversation: bool = True,
     truncate_results: bool = False,
 ) -> Callable[..., Command]:
     """
@@ -64,6 +65,16 @@ def create_genie_tool(
     Returns:
         A LangGraph tool that processes natural language queries through Genie
     """
+    logger.debug("create_genie_tool")
+    logger.debug(f"genie_room type: {type(genie_room)}")
+    logger.debug(f"genie_room: {genie_room}")
+    logger.debug(f"persist_conversation: {persist_conversation}")
+    logger.debug(f"truncate_results: {truncate_results}")
+    logger.debug(f"name: {name}")
+    logger.debug(f"description: {description}")
+    logger.debug(f"genie_room: {genie_room}")
+    logger.debug(f"persist_conversation: {persist_conversation}")
+    logger.debug(f"truncate_results: {truncate_results}")
 
     if isinstance(genie_room, dict):
         genie_room = GenieRoomModel(**genie_room)
@@ -106,14 +117,13 @@ GenieResponse: A response object containing the conversation ID and result from
         state: Annotated[dict, InjectedState],
         tool_call_id: Annotated[str, InjectedToolCallId],
     ) -> Command:
-        """Process a natural language question through Databricks Genie."""
-        # Create Genie instance using databricks_langchain implementation
         genie: Genie = Genie(
             space_id=space_id,
             client=genie_room.workspace_client,
             truncate_results=truncate_results,
         )
 
+        """Process a natural language question through Databricks Genie."""
         # Get existing conversation mapping and retrieve conversation ID for this space
         conversation_ids: dict[str, str] = state.get("genie_conversation_ids", {})
         existing_conversation_id: str | None = conversation_ids.get(space_id)
@@ -131,6 +141,7 @@ GenieResponse: A response object containing the conversation ID and result from
         )
 
         # Update the conversation mapping with the new conversation ID for this space
+
         update: dict[str, Any] = {
             "messages": [
                 ToolMessage(_response_to_json(response), tool_call_id=tool_call_id)

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/tools/unity_catalog.py

@@ -15,6 +15,7 @@ from dao_ai.config import (
     value_of,
 )
 from dao_ai.tools.human_in_the_loop import as_human_in_the_loop
+from dao_ai.utils import normalize_host
 
 
 def create_uc_tools(
@@ -299,9 +300,11 @@ def with_partial_args(
             if "client_secret" not in resolved_args:
                 resolved_args["client_secret"] = value_of(sp.client_secret)
 
-    # Normalize host/workspace_host - accept either key
+    # Normalize host/workspace_host - accept either key, ensure https:// scheme
     if "workspace_host" in resolved_args and "host" not in resolved_args:
-        resolved_args["host"] = resolved_args.pop("workspace_host")
+        resolved_args["host"] = normalize_host(resolved_args.pop("workspace_host"))
+    elif "host" in resolved_args:
+        resolved_args["host"] = normalize_host(resolved_args["host"])
 
     # Default host from WorkspaceClient if not provided
     if "host" not in resolved_args:

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/tools/vector_search.py

@@ -20,6 +20,7 @@ from dao_ai.config import (
     RetrieverModel,
     VectorStoreModel,
 )
+from dao_ai.utils import normalize_host
 
 
 def create_vector_search_tool(
@@ -108,8 +109,9 @@ def create_vector_search_tool(
     # The workspace_client parameter in DatabricksVectorSearch is only used to detect
     # model serving mode - it doesn't pass credentials to VectorSearchClient.
     client_args: dict[str, Any] = {}
-    if os.environ.get("DATABRICKS_HOST"):
-        client_args["workspace_url"] = os.environ.get("DATABRICKS_HOST")
+    databricks_host = normalize_host(os.environ.get("DATABRICKS_HOST"))
+    if databricks_host:
+        client_args["workspace_url"] = databricks_host
     if os.environ.get("DATABRICKS_TOKEN"):
         client_args["personal_access_token"] = os.environ.get("DATABRICKS_TOKEN")
     if os.environ.get("DATABRICKS_CLIENT_ID"):

{dao_ai-0.0.33 → dao_ai-0.0.35}/src/dao_ai/utils.py

@@ -38,6 +38,30 @@ def normalize_name(name: str) -> str:
     return normalized.strip("_")
 
 
+def normalize_host(host: str | None) -> str | None:
+    """Ensure host URL has https:// scheme.
+
+    The DATABRICKS_HOST environment variable should always include the https://
+    scheme, but some environments (e.g., Databricks Apps infrastructure) may
+    provide the host without it. This function normalizes the host to ensure
+    it has the proper scheme.
+
+    Args:
+        host: The host URL, with or without scheme
+
+    Returns:
+        The host URL with https:// scheme, or None if host is None/empty
+    """
+    if not host:
+        return None
+    host = host.strip()
+    if not host:
+        return None
+    if not host.startswith("http://") and not host.startswith("https://"):
+        return f"https://{host}"
+    return host
+
+
 def get_default_databricks_host() -> str | None:
     """Get the default Databricks workspace host.
 
@@ -46,19 +70,19 @@ def get_default_databricks_host() -> str | None:
     2. WorkspaceClient ambient authentication (e.g., from ~/.databrickscfg)
 
     Returns:
-        The Databricks workspace host URL, or None if not available.
+        The Databricks workspace host URL (with https:// scheme), or None if not available.
     """
     # Try environment variable first
     host: str | None = os.environ.get("DATABRICKS_HOST")
     if host:
-        return host
+        return normalize_host(host)
 
     # Fall back to WorkspaceClient
     try:
         from databricks.sdk import WorkspaceClient
 
         w: WorkspaceClient = WorkspaceClient()
-        return w.config.host
+        return normalize_host(w.config.host)
     except Exception:
         logger.debug("Could not get default Databricks host from WorkspaceClient")
         return None

{dao_ai-0.0.33 → dao_ai-0.0.35}/tests/dao_ai/test_genie_databricks_integration.py

@@ -26,7 +26,6 @@ from conftest import has_databricks_env
 from langchain_core.tools import StructuredTool
 
 from dao_ai.config import GenieRoomModel
-from dao_ai.state import SharedState
 from dao_ai.tools.genie import GenieToolInput
 
 
@@ -98,19 +97,24 @@ class TestGenieDatabricksIntegration:
     RESULT: Tool validation only includes user inputs, not LangGraph injected state
     """
 
-    def test_genie_tool_schema_excludes_injected_parameters(self, mock_genie_tool):
-        """Test that the tool schema properly marks injected parameters using Annotated."""
+    def test_genie_tool_uses_injected_state_pattern(self, mock_genie_tool):
+        """Test that the tool uses the InjectedState pattern for accessing state."""
         tool = mock_genie_tool
 
-        # The @tool decorator creates its own schema, but it should have injected parameters marked
-        # Verify the schema includes all parameters
-        schema = tool.args_schema.model_json_schema()
-        properties = schema.get("properties", {})
+        # Verify the function signature has injected parameters
+        import inspect
 
-        # With @tool decorator, all parameters are in schema but injected ones are marked with Annotated
-        assert "question" in properties
-        # Note: With @tool decorator, state and tool_call_id may appear in schema
-        # but they're marked as injected via Annotated types
+        sig = inspect.signature(tool.func)
+        params = list(sig.parameters.keys())
+
+        # With @tool decorator and InjectedState/InjectedToolCallId, the function signature
+        # includes question, state, and tool_call_id
+        assert "question" in params
+        assert "state" in params
+        assert "tool_call_id" in params
+
+        # The InjectedState and InjectedToolCallId parameters will be injected by LangGraph
+        # at runtime and hidden from the model
 
     def test_genie_tool_input_validation_success(self):
         """Test that GenieToolInput validates correctly with just question."""
@@ -177,7 +181,7 @@ class TestGenieDatabricksIntegration:
         sig = inspect.signature(tool.func)
         params = list(sig.parameters.keys())
 
-        # Should have all three parameters: question, state, tool_call_id
+        # Should have question, state, and tool_call_id parameters
         assert "question" in params
         assert "state" in params
         assert "tool_call_id" in params
@@ -212,19 +216,16 @@ class TestGenieDatabricksIntegration:
     @pytest.mark.skipif(not has_databricks_env(), reason="Databricks env vars not set")
     def test_conversation_persistence_with_injected_state(self, mock_genie_tool):
         """
-        Test that conversation persistence works correctly with injected state pattern.
+        Test that conversation persistence works correctly with InjectedState pattern.
 
         This verifies that the fix doesn't break the core functionality of
         conversation mapping using space_id from the state.
         """
-        # Create state with conversation mapping
-        mock_state = SharedState(
-            context={},
-            conversations={"test-space-123": "existing-conversation-id"},
-            messages=[],
-            config=Mock(),
-            user_id="test-user",
-        )
+        # Create a mock state dict
+        mock_state = {
+            "genie_conversation_ids": {"test-space-123": "existing-conversation-id"},
+            "messages": [],
+        }
 
         # Use the fixture genie tool
         tool = mock_genie_tool
@@ -243,13 +244,12 @@ class TestGenieDatabricksIntegration:
         assert result.update is not None
         assert "genie_conversation_ids" in result.update
 
-    def test_original_error_reproduction_prevention(self, mock_genie_tool):
+    def test_injected_state_pattern(self, mock_genie_tool):
         """
-        Test that demonstrates the original error is prevented by using @tool decorator.
+        Test that the tool uses the InjectedState pattern.
 
-        The @tool decorator with Annotated types (InjectedState, InjectedToolCallId)
-        tells LangGraph to inject these parameters at runtime, so they don't need
-        to be provided by the user.
+        The InjectedState and InjectedToolCallId annotations provide access
+        to state and tool_call_id through LangGraph's dependency injection.
         """
         tool = mock_genie_tool
 
@@ -263,13 +263,13 @@ class TestGenieDatabricksIntegration:
         sig = inspect.signature(tool.func)
         params = list(sig.parameters.keys())
 
-        # All parameters should be present in signature
+        # Should have question, state, and tool_call_id parameters
         assert "question" in params
         assert "state" in params
         assert "tool_call_id" in params
 
-        # The key fix: Using Annotated with InjectedState and InjectedToolCallId
-        # tells LangGraph to inject these at runtime, preventing validation errors
+        # The InjectedState and InjectedToolCallId annotations tell LangGraph
+        # to inject these parameters at runtime
 
 
 if __name__ == "__main__":