copilotagent 0.1.6__py3-none-any.whl

copilotagent/__init__.py

@@ -0,0 +1,35 @@
+"""CopilotAgent package."""
+
+__author__ = """Harrison Chase"""
+__email__ = "harrison@langchain.dev"
+__version__ = "0.1.6"
+
+from copilotagent.cloud_subagents import (
+    get_cute_finish_itp_subagent,
+    get_cute_linear_subagent,
+)
+from copilotagent.graph import (
+    create_deep_agent,
+    DEFAULT_AGENT_TYPE,
+    DEFAULT_STARTING_MESSAGES,
+    get_default_starting_message,
+)
+from copilotagent.middleware.filesystem import FilesystemMiddleware
+from copilotagent.middleware.initial_message import InitialMessageMiddleware
+from copilotagent.middleware.planning import PlanningMiddleware
+from copilotagent.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
+
+__all__ = [
+    "CompiledSubAgent",
+    "DEFAULT_AGENT_TYPE",
+    "DEFAULT_STARTING_MESSAGES",
+    "FilesystemMiddleware",
+    "InitialMessageMiddleware",
+    "PlanningMiddleware",
+    "SubAgent",
+    "SubAgentMiddleware",
+    "create_deep_agent",
+    "get_cute_finish_itp_subagent",
+    "get_cute_linear_subagent",
+    "get_default_starting_message",
+]

copilotagent/cloud_subagents.py

@@ -0,0 +1,220 @@
+"""Cloud subagents using LangGraph Cloud deployed services.
+
+This module provides factory functions for creating CompiledSubAgent instances
+that connect to deployed LangGraph Cloud services via LangGraph SDK client.
+"""
+
+import logging
+import os
+from pathlib import Path
+from typing import Any, TypedDict
+
+from dotenv import load_dotenv
+from langchain_core.runnables import Runnable
+from langgraph_sdk import get_client
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+# Try to load .env from multiple possible locations
+env_locations = [
+    Path.cwd() / ".env",  # Current working directory
+    Path(__file__).parent.parent.parent.parent / ".env",  # copilot/.env
+    Path(__file__).parent.parent.parent.parent / "agents" / "ITP-Princeton" / ".env",  # ITP-Princeton/.env
+]
+
+for env_path in env_locations:
+    if env_path.exists():
+        logger.info(f"Loading .env from: {env_path}")
+        load_dotenv(env_path)
+        break
+else:
+    logger.warning(f"No .env file found in any of these locations: {env_locations}")
+
+
+class RemoteGraphRunnable(Runnable):
+    """Wrapper to make LangGraph SDK client work as a Runnable.
+    
+    This adapter allows the new LangGraph SDK client API to work with
+    the existing Runnable interface expected by SubAgentMiddleware.
+    """
+    
+    def __init__(self, url: str, api_key: str, graph_id: str):
+        """Initialize the remote graph runnable.
+        
+        Args:
+            url: The URL of the deployed LangGraph service
+            api_key: The API key for authentication
+            graph_id: The graph ID to use (assistant_id)
+        """
+        self.url = url
+        self.api_key = api_key
+        self.graph_id = graph_id
+        self._client = None
+    
+    @property
+    def client(self):
+        """Lazy initialization of the client."""
+        if self._client is None:
+            self._client = get_client(url=self.url, api_key=self.api_key)
+        return self._client
+    
+    def invoke(self, input: dict[str, Any], config: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Synchronously invoke the remote graph.
+        
+        Args:
+            input: The input state dictionary
+            config: Optional configuration
+            
+        Returns:
+            The final state from the remote graph execution
+        """
+        import asyncio
+        return asyncio.run(self.ainvoke(input, config))
+    
+    async def ainvoke(self, input: dict[str, Any], config: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Asynchronously invoke the remote graph.
+        
+        Args:
+            input: The input state dictionary
+            config: Optional configuration
+            
+        Returns:
+            The final state from the remote graph execution
+        """
+        # Use the runs.wait method to execute and wait for completion
+        result = await self.client.runs.wait(
+            thread_id=None,  # Create a new thread for each invocation
+            assistant_id=self.graph_id,
+            input=input,
+        )
+        # Return the final state from the result
+        return result
+
+
+class CompiledSubAgent(TypedDict):
+    """A pre-compiled agent spec."""
+
+    name: str
+    """The name of the agent."""
+
+    description: str
+    """The description of the agent."""
+
+    runnable: Runnable
+    """The Runnable to use for the agent."""
+
+
+def get_cute_linear_subagent() -> CompiledSubAgent:
+    """Get cuteLinear cloud subagent for GUI data extraction.
+
+    This agent performs automated GUI data extraction including:
+    - Multi-step GUI navigation
+    - Screenshot capture
+    - OCR via AWS Textract
+    - AI-powered name normalization
+    - Human-in-the-loop review
+    - SharedState reporting
+
+    Returns:
+        CompiledSubAgent dictionary with RemoteGraph runnable.
+        
+    Raises:
+        ValueError: If API key environment variable is not set.
+    """
+    # Try multiple environment variable names (LangChain uses different names in different contexts)
+    api_key = (
+        os.getenv("LANGCHAIN_API_KEY") or 
+        os.getenv("LANGSMITH_API_KEY") or 
+        os.getenv("LANGGRAPH_API_KEY")
+    )
+    
+    # Log environment variable status for debugging
+    logger.info(f"LANGCHAIN_API_KEY present: {bool(os.getenv('LANGCHAIN_API_KEY'))}")
+    logger.info(f"LANGSMITH_API_KEY present: {bool(os.getenv('LANGSMITH_API_KEY'))}")
+    logger.info(f"LANGGRAPH_API_KEY present: {bool(os.getenv('LANGGRAPH_API_KEY'))}")
+    logger.info(f"Current working directory: {Path.cwd()}")
+    logger.info(f"All env vars with 'LANG': {[k for k in os.environ.keys() if 'LANG' in k]}")
+    
+    if not api_key:
+        msg = (
+            "API key environment variable is required for cloud subagents. "
+            "Please ensure .env file exists with one of: LANGCHAIN_API_KEY, LANGSMITH_API_KEY, or LANGGRAPH_API_KEY. "
+            f"Checked locations: {env_locations}"
+        )
+        logger.error(msg)
+        raise ValueError(msg)
+
+    logger.info(f"Creating RemoteGraphRunnable for cute-linear with API key: {api_key[:10]}...")
+    client = RemoteGraphRunnable(
+        url="https://cutelineargraph-ef1ae523c24e51ef94e330929a65833b.us.langgraph.app",
+        api_key=api_key,
+        graph_id="cuteLinearGraph",
+    )
+
+    return {
+        "name": "cute-linear",
+        "description": (
+            "Coordinated Data Extraction Agent - Performs automated GUI data extraction "
+            "including navigation, OCR via AWS Textract, and AI-powered name normalization. "
+            "Extracts borrower names from GUI interface, sends for human review, and reports "
+            "results back. Use this agent when you need to extract borrower names from the "
+            "GUI system."
+        ),
+        "runnable": client,
+    }
+
+
+def get_cute_finish_itp_subagent() -> CompiledSubAgent:
+    """Get cuteFinishITP cloud subagent for GUI automation.
+
+    This agent executes a 25-step workflow for ITP document processing including:
+    - Popup detection and handling
+    - Form field navigation and filling
+    - Document verification
+    - Final document submission
+    - Screenshot capture for verification
+
+    Returns:
+        CompiledSubAgent dictionary with RemoteGraph runnable.
+        
+    Raises:
+        ValueError: If API key environment variable is not set.
+    """
+    # Try multiple environment variable names (LangChain uses different names in different contexts)
+    api_key = (
+        os.getenv("LANGCHAIN_API_KEY") or 
+        os.getenv("LANGSMITH_API_KEY") or 
+        os.getenv("LANGGRAPH_API_KEY")
+    )
+    
+    # Log environment variable status for debugging
+    logger.info(f"API key present: {bool(api_key)}")
+    
+    if not api_key:
+        msg = (
+            "API key environment variable is required for cloud subagents. "
+            "Please ensure .env file exists with one of: LANGCHAIN_API_KEY, LANGSMITH_API_KEY, or LANGGRAPH_API_KEY. "
+            f"Checked locations: {env_locations}"
+        )
+        logger.error(msg)
+        raise ValueError(msg)
+
+    logger.info(f"Creating RemoteGraphRunnable for cute-finish-itp with API key: {api_key[:10]}...")
+    client = RemoteGraphRunnable(
+        url="https://cutefinishitp-2d3fcf81a7e55dd09a66354c5c2b567c.us.langgraph.app",
+        api_key=api_key,
+        graph_id="cuteFinishITP",
+    )
+
+    return {
+        "name": "cute-finish-itp",
+        "description": (
+            "Encompass GUI Automation Agent - Executes a 25-step workflow for ITP document "
+            "processing including popup detection, form filling, document verification, and "
+            "final submission. Use this agent when you need to complete the ITP document "
+            "processing workflow in the Encompass GUI system."
+        ),
+        "runnable": client,
+    }
+

copilotagent/graph.py

@@ -0,0 +1,192 @@
+"""Deepagents come with planning, filesystem, and subagents."""
+
+from collections.abc import Callable, Sequence
+from typing import Any, Literal
+
+from langchain.agents import create_agent
+from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig
+from langchain.agents.middleware.summarization import SummarizationMiddleware
+from langchain.agents.middleware.types import AgentMiddleware
+from langchain.agents.structured_output import ResponseFormat
+from langchain_anthropic import ChatAnthropic
+from langchain_anthropic.middleware import AnthropicPromptCachingMiddleware
+from langchain_core.language_models import BaseChatModel
+from langchain_core.tools import BaseTool
+from langgraph.cache.base import BaseCache
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.store.base import BaseStore
+from langgraph.types import Checkpointer
+
+from copilotagent.middleware.filesystem import FilesystemMiddleware
+from copilotagent.middleware.initial_message import InitialMessageMiddleware
+from copilotagent.middleware.patch_tool_calls import PatchToolCallsMiddleware
+from copilotagent.middleware.planning import PlanningMiddleware
+from copilotagent.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
+
+# Global default agent type for planning middleware
+DEFAULT_AGENT_TYPE: Literal["ITP-Princeton", "DrawDoc-AWM", "research"] = "ITP-Princeton"
+
+BASE_AGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools."
+
+# Default starting messages for different agent types
+DEFAULT_STARTING_MESSAGES = {
+    "ITP-Princeton": "Let's review and approve Intent to Proceed for Princeton mortgage",
+    "DrawDoc-AWM": "Let's draw the docs for AWM",
+    "research": None,  # Research agents still get human input
+}
+
+
+def get_default_model() -> ChatAnthropic:
+    """Get the default model for deep agents.
+
+    Returns:
+        ChatAnthropic instance configured with Claude Sonnet 4.
+    """
+    return ChatAnthropic(
+        model_name="claude-sonnet-4-5-20250929",
+        max_tokens=20000,
+    )
+
+
+def get_default_starting_message(
+    agent_type: Literal["ITP-Princeton", "DrawDoc-AWM", "research"]
+) -> str | None:
+    """Get the default starting message for an agent type.
+
+    Args:
+        agent_type: The type of agent.
+
+    Returns:
+        Default starting message for the agent type, or None if no default.
+    """
+    return DEFAULT_STARTING_MESSAGES.get(agent_type)
+
+
+def create_deep_agent(
+    model: str | BaseChatModel | None = None,
+    tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
+    *,
+    system_prompt: str | None = None,
+    middleware: Sequence[AgentMiddleware] = (),
+    subagents: list[SubAgent | CompiledSubAgent] | None = None,
+    response_format: ResponseFormat | None = None,
+    context_schema: type[Any] | None = None,
+    checkpointer: Checkpointer | None = None,
+    store: BaseStore | None = None,
+    use_longterm_memory: bool = False,
+    interrupt_on: dict[str, bool | InterruptOnConfig] | None = None,
+    agent_type: Literal["ITP-Princeton", "DrawDoc-AWM", "research"] | None = None,
+    debug: bool = False,
+    name: str | None = None,
+    cache: BaseCache | None = None,
+) -> CompiledStateGraph:
+    """Create a deep agent.
+
+    This agent will by default have access to a tool to write todos (write_todos),
+    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call
+    subagents.
+
+    Args:
+        tools: The tools the agent should have access to.
+        system_prompt: The additional instructions the agent should have. Will go in
+            the system prompt.
+        middleware: Additional middleware to apply after standard middleware.
+        model: The model to use.
+        subagents: The subagents to use. Each subagent should be a dictionary with the
+            following keys:
+                - `name`
+                - `description` (used by the main agent to decide whether to call the
+                  sub agent)
+                - `prompt` (used as the system prompt in the subagent)
+                - (optional) `tools`
+                - (optional) `model` (either a LanguageModelLike instance or dict
+                  settings)
+                - (optional) `middleware` (list of AgentMiddleware)
+        response_format: A structured output response format to use for the agent.
+        context_schema: The schema of the deep agent.
+        checkpointer: Optional checkpointer for persisting agent state between runs.
+        store: Optional store for persisting longterm memories.
+        use_longterm_memory: Whether to use longterm memory - you must provide a store
+            in order to use longterm memory.
+        interrupt_on: Optional Dict[str, bool | InterruptOnConfig] mapping tool names to
+            interrupt configs.
+        agent_type: Type of agent for planning prompts. Options: "ITP-Princeton",
+            "DrawDoc-AWM", "research". Defaults to the global DEFAULT_AGENT_TYPE.
+        debug: Whether to enable debug mode. Passed through to create_agent.
+        name: The name of the agent. Passed through to create_agent.
+        cache: The cache to use for the agent. Passed through to create_agent.
+
+    Returns:
+        A configured deep agent.
+    """
+    if model is None:
+        model = get_default_model()
+
+    # Use the provided agent_type or fall back to the global default
+    if agent_type is None:
+        agent_type = DEFAULT_AGENT_TYPE
+
+    # Get the default starting message for this agent type
+    default_starting_message = get_default_starting_message(agent_type)
+
+    deepagent_middleware = [
+        # Add initial message middleware first, so it can present default message
+        # before any other processing happens
+        InitialMessageMiddleware(
+            agent_type=agent_type,
+            default_message=default_starting_message,
+        ),
+        PlanningMiddleware(
+            agent_type=agent_type,
+        ),
+        FilesystemMiddleware(
+            long_term_memory=use_longterm_memory,
+        ),
+        SubAgentMiddleware(
+            default_model=model,
+            default_tools=tools,
+            subagents=subagents if subagents is not None else [],
+            default_middleware=[
+                PlanningMiddleware(
+                    agent_type=agent_type,
+                ),
+                FilesystemMiddleware(
+                    long_term_memory=use_longterm_memory,
+                ),
+                SummarizationMiddleware(
+                    model=model,
+                    max_tokens_before_summary=170000,
+                    messages_to_keep=6,
+                ),
+                AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
+                PatchToolCallsMiddleware(),
+            ],
+            default_interrupt_on=interrupt_on,
+            general_purpose_agent=True,
+        ),
+        SummarizationMiddleware(
+            model=model,
+            max_tokens_before_summary=170000,
+            messages_to_keep=6,
+        ),
+        AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
+        PatchToolCallsMiddleware(),
+    ]
+    if interrupt_on is not None:
+        deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=interrupt_on))
+    if middleware is not None:
+        deepagent_middleware.extend(middleware)
+
+    return create_agent(
+        model,
+        system_prompt=system_prompt + "\n\n" + BASE_AGENT_PROMPT if system_prompt else BASE_AGENT_PROMPT,
+        tools=tools,
+        middleware=deepagent_middleware,
+        response_format=response_format,
+        context_schema=context_schema,
+        checkpointer=checkpointer,
+        store=store,
+        debug=debug,
+        name=name,
+        cache=cache,
+    ).with_config({"recursion_limit": 1000})

copilotagent/middleware/__init__.py

@@ -0,0 +1,15 @@
+"""Middleware for the CopilotAgent."""
+
+from copilotagent.middleware.filesystem import FilesystemMiddleware
+from copilotagent.middleware.initial_message import InitialMessageMiddleware
+from copilotagent.middleware.planning import PlanningMiddleware
+from copilotagent.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
+
+__all__ = [
+    "CompiledSubAgent",
+    "FilesystemMiddleware",
+    "InitialMessageMiddleware",
+    "PlanningMiddleware",
+    "SubAgent",
+    "SubAgentMiddleware",
+]