rossum-agent 1.0.0rc0__py3-none-any.whl

rossum_agent/streamlit_app/cli.py

@@ -0,0 +1,17 @@
+"""CLI entry point for Rossum Agent Streamlit application."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def main() -> None:
+    """Launch the Rossum Agent Streamlit application."""
+    app_path = Path(__file__).parent / "app.py"
+    sys.exit(subprocess.call([sys.executable, "-m", "streamlit", "run", str(app_path), *sys.argv[1:]]))
+
+
+if __name__ == "__main__":
+    main()

rossum_agent/streamlit_app/render_modules.py

@@ -0,0 +1,123 @@
+"""Streamlit UI rendering modules for the Rossum Agent app."""
+
+from __future__ import annotations
+
+import html
+import re
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+import streamlit as st
+import streamlit.components.v1 as components
+
+if TYPE_CHECKING:
+    from rossum_agent.redis_storage import RedisStorage
+
+MERMAID_BLOCK_PATTERN = re.compile(r"```mermaid\s*(.*?)```", re.DOTALL)
+
+MERMAID_HTML_TEMPLATE = """
+<script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+<script>mermaid.initialize({{startOnLoad: true, theme: 'default'}});</script>
+<div class="mermaid" style="background: white; padding: 10px; border-radius: 5px;">
+{code}
+</div>
+"""
+
+
+def render_mermaid_html(code: str, height: int = 400) -> None:
+    """Render mermaid diagram using HTML component."""
+    escaped_code = html.escape(code.strip())
+    html_content = MERMAID_HTML_TEMPLATE.format(code=escaped_code)
+    components.html(html_content, height=height, scrolling=True)
+
+
+def render_markdown_with_mermaid(content: str) -> None:
+    """Render markdown content with mermaid diagram support.
+
+    Parses markdown content for ```mermaid``` code blocks and renders them
+    using HTML components. Other content is rendered with st.markdown.
+    """
+    parts = MERMAID_BLOCK_PATTERN.split(content)
+    for i, part in enumerate(parts):
+        if not part.strip():
+            continue
+        if i % 2 == 1:
+            render_mermaid_html(part)
+        else:
+            st.markdown(part)
+
+
+def render_chat_history(redis_storage: RedisStorage, current_chat_id: str, user_id: str | None = None) -> None:
+    """Render the chat history section in the sidebar.
+
+    Args:
+        redis_storage: Redis storage instance for retrieving chat history
+        current_chat_id: The currently active chat ID
+        user_id: Optional user ID for filtering chat history
+    """
+    st.markdown("---")
+    st.subheader("Chat History")
+
+    if redis_storage.is_connected():
+        all_chats = redis_storage.list_all_chats(user_id)
+
+        if all_chats:
+            # Group chats by time period
+            now = datetime.now()
+            today_chats = []
+            last_30_days_chats = []
+
+            for chat in all_chats:
+                chat_date = datetime.fromtimestamp(chat["timestamp"])
+                days_ago = (now - chat_date).days
+
+                if days_ago == 0:
+                    today_chats.append(chat)
+                elif days_ago <= 30:
+                    last_30_days_chats.append(chat)
+
+            # Display Today section
+            if today_chats:
+                st.markdown("**Today**")
+                for chat in today_chats:
+                    is_current = chat["chat_id"] == current_chat_id
+                    prefix = "📌 " if is_current else "💬 "
+                    chat_title = (
+                        chat["first_message"][:40] + "..."
+                        if len(chat["first_message"]) > 40
+                        else chat["first_message"]
+                    )
+
+                    if st.button(
+                        f"{prefix}{chat_title}",
+                        key=f"chat_{chat['chat_id']}",
+                        use_container_width=True,
+                        disabled=is_current,
+                    ):
+                        st.query_params["chat_id"] = chat["chat_id"]
+                        st.rerun()
+
+            # Display Previous 30 days section
+            if last_30_days_chats:
+                with st.expander("**Previous 30 days**", expanded=False):
+                    for chat in last_30_days_chats:
+                        is_current = chat["chat_id"] == current_chat_id
+                        prefix = "📌 " if is_current else "💬 "
+                        chat_title = (
+                            chat["first_message"][:40] + "..."
+                            if len(chat["first_message"]) > 40
+                            else chat["first_message"]
+                        )
+
+                        if st.button(
+                            f"{prefix}{chat_title}",
+                            key=f"chat_{chat['chat_id']}",
+                            use_container_width=True,
+                            disabled=is_current,
+                        ):
+                            st.query_params["chat_id"] = chat["chat_id"]
+                            st.rerun()
+        else:
+            st.info("No chat history yet")
+    else:
+        st.warning("Redis not connected - chat history unavailable")

rossum_agent/streamlit_app/response_formatting.py

@@ -0,0 +1,305 @@
+"""Response formatting module for the Rossum Agent Streamlit application.
+
+This module handles the formatting and display of agent responses,
+including tool calls, tool results, and final answers.
+"""
+
+from __future__ import annotations
+
+import ast
+import contextlib
+import dataclasses
+import json
+import pathlib
+from typing import TYPE_CHECKING, Any, Protocol
+
+if TYPE_CHECKING:
+    from streamlit.delta_generator import DeltaGenerator
+
+    from rossum_agent.agent import AgentStep
+    from rossum_agent.tools.core import SubAgentProgress
+
+
+class OutputRenderer(Protocol):
+    def markdown(self, body: str, *, unsafe_allow_html: bool = False) -> None: ...
+
+
+def get_display_tool_name(tool_call_name: str, tool_arguments: dict[str, Any] | None = None) -> str:
+    """Get display name for a tool, expanding call_on_connection to show the actual MCP tool.
+
+    For call_on_connection, returns 'call_on_connection[connection_id.tool_name]' format.
+    For other tools, returns the original name.
+    """
+    if tool_call_name == "call_on_connection" and tool_arguments:
+        connection_id = tool_arguments.get("connection_id", "")
+        inner_tool = tool_arguments.get("tool_name", "")
+        if connection_id and inner_tool:
+            return f"call_on_connection[{connection_id}.{inner_tool}]"
+    return tool_call_name
+
+
+def parse_and_format_final_answer(answer: str) -> str:
+    """Parse and format final answer if it's a dictionary."""
+    answer = answer.strip()
+
+    with contextlib.suppress(json.JSONDecodeError, ValueError):
+        data = json.loads(answer)
+        if isinstance(data, dict):
+            return FinalResponse(data).get_formatted_response()
+
+    with contextlib.suppress(ValueError, SyntaxError):
+        data = ast.literal_eval(answer)
+        if isinstance(data, dict):
+            return FinalResponse(data).get_formatted_response()
+
+    return answer
+
+
+@dataclasses.dataclass
+class FinalResponse:
+    data: dict[str, Any]
+
+    def __post_init__(self) -> None:
+        self.lines: list[str] = []
+        self.processed_keys: set[str] = set()
+
+        self._called: bool = False
+
+    def get_formatted_response(self) -> str:
+        """Format dictionary response."""
+        if self._called:
+            return "\n".join(self.lines)
+
+        if "status" in self.data:
+            self.add_status()
+
+        if "summary" in self.data:
+            self.add_summary()
+
+        self.add_generated_files()
+
+        self.add_generic_items()
+
+        self._called = True
+
+        return "\n".join(self.lines)
+
+    def add_status(self) -> None:
+        status_emoji = "✅" if self.data["status"] == "success" else "❌"
+        self.lines.append(f"### {status_emoji} Status: {self.data['status'].title()}\n")
+        self.processed_keys.add("status")
+
+    def add_summary(self) -> None:
+        self.lines.append("### 📝 Summary")
+        self.lines.append(self.data["summary"])
+        self.lines.append("")
+        self.processed_keys.add("summary")
+
+    def add_generated_files(self) -> None:
+        for key in self.data:
+            if (
+                key not in self.processed_keys
+                and isinstance(self.data[key], list)
+                and ("generated" in key.lower() or "files" in key.lower())
+            ):
+                self.lines.append(f"### 📁 {key.replace('_', ' ').title()}")
+                for item in self.data[key]:
+                    if isinstance(item, str):
+                        file_name = pathlib.Path(item).name if "/" in item or "\\" in item else item
+                        self.lines.append(f"- `{file_name}`")
+                    else:
+                        self.lines.append(f"- {item}")
+                self.lines.append("")
+                self.processed_keys.add(key)
+
+    def add_generic_items(self) -> None:
+        for key, value in self.data.items():
+            if key in self.processed_keys:
+                continue
+
+            formatted_key = key.replace("_", " ").title()
+
+            if isinstance(value, dict):
+                self.lines.append(f"### {formatted_key}")
+                for sub_key, sub_value in value.items():
+                    self.lines.append(f"- **{sub_key.replace('_', ' ').title()}:** {sub_value}")
+                self.lines.append("")
+            elif isinstance(value, list):
+                self.lines.append(f"### {formatted_key}")
+                for item in value:
+                    self.lines.append(f"- {item}")
+                self.lines.append("")
+            else:
+                self.lines.append(f"**{formatted_key}:** {value}")
+
+
+@dataclasses.dataclass
+class ChatResponse:
+    """Handles formatting and display of agent responses.
+
+    This class processes AgentStep objects from the new Claude-based agent
+    and renders them appropriately in the Streamlit UI. Supports streaming
+    updates where thinking is displayed progressively.
+    """
+
+    prompt: str
+    output_placeholder: OutputRenderer | DeltaGenerator
+
+    def __post_init__(self) -> None:
+        self.result: AgentStep | None = None
+        self.completed_steps_markdown: list[str] = []
+        self.current_step_markdown: str = ""
+        self.final_answer_text: str | None = None
+        self._current_step_num: int = 0
+        self.total_input_tokens: int = 0
+        self.total_output_tokens: int = 0
+        self.total_tool_calls: int = 0
+        self.total_steps: int = 0
+
+    def process_step(self, step: AgentStep) -> None:
+        """Process and display an agent step.
+
+        Args:
+            step: An AgentStep from the agent's execution.
+        """
+        if step.is_streaming:
+            self._process_streaming_step(step)
+        else:
+            self._process_completed_step(step)
+
+        self._render_display(step)
+
+        if not step.is_streaming:
+            self.result = step
+            self.total_input_tokens += step.input_tokens
+            self.total_output_tokens += step.output_tokens
+            self.total_tool_calls += len(step.tool_calls)
+            self.total_steps += 1
+
+    def _process_streaming_step(self, step: AgentStep) -> None:
+        """Process a streaming step (partial thinking, text, or tool execution).
+
+        Handles three types of streaming content (matching API's agent_service.py):
+        - thinking: Model's chain-of-thought reasoning
+        - intermediate: Model's response text before tool calls (via accumulated_text)
+        - final_answer: Model's final response streaming (via accumulated_text)
+        """
+        if step.step_number != self._current_step_num:
+            if self.current_step_markdown:
+                self.completed_steps_markdown.append(self.current_step_markdown)
+            self._current_step_num = step.step_number
+            self.current_step_markdown = f"#### Step {step.step_number}\n"
+
+        if step.current_tool and step.tool_progress:
+            current, total = step.tool_progress
+            current_tool_args = None
+            for tc in step.tool_calls:
+                if tc.name == step.current_tool:
+                    current_tool_args = tc.arguments
+                    break
+            display_name = get_display_tool_name(step.current_tool, current_tool_args)
+            progress_text = f"🔧 Running tool {current}/{total}: **{display_name}**..."
+
+            if step.sub_agent_progress:
+                sub_progress = step.sub_agent_progress
+                sub_agent_text = self._format_sub_agent_progress(sub_progress)
+                progress_text = f"{progress_text}\n\n{sub_agent_text}"
+
+            parts = [f"#### Step {step.step_number}\n"]
+            if step.thinking:
+                parts.append(f"🧠 **Thinking:**\n\n{step.thinking}\n")
+            if step.accumulated_text:
+                parts.append(f"💬 **Response:**\n\n{step.accumulated_text}\n")
+            parts.append(f"{progress_text}\n")
+            self.current_step_markdown = "\n".join(parts)
+        elif step.accumulated_text is not None:
+            parts = [f"#### Step {step.step_number}\n"]
+            if step.thinking:
+                parts.append(f"🧠 **Thinking:**\n\n{step.thinking}\n")
+            parts.append(f"💬 **Response:**\n\n{step.accumulated_text}\n")
+            self.current_step_markdown = "\n".join(parts)
+        elif step.thinking:
+            self.current_step_markdown = f"#### Step {step.step_number}\n\n🧠 **Thinking:**\n\n{step.thinking}\n"
+
+    def _format_sub_agent_progress(self, progress: SubAgentProgress) -> str:
+        """Format sub-agent progress for display."""
+        iteration = progress.iteration
+        max_iterations = progress.max_iterations
+        status = progress.status
+        current_tool = progress.current_tool
+        tool_calls = progress.tool_calls
+
+        if max_iterations > 0:
+            lines = [f"> 🤖 **Sub-agent ({progress.tool_name})** - Iteration {iteration}/{max_iterations}"]
+        else:
+            lines = [f"> 🤖 **Sub-agent ({progress.tool_name})**"]
+
+        if status == "thinking":
+            lines.append("> ⏳ _Thinking..._")
+        elif status == "searching":
+            lines.append("> 🔍 _Searching Knowledge Base..._")
+        elif status == "analyzing":
+            lines.append("> 🧠 _Analyzing results..._")
+        elif status == "running_tool" and current_tool:
+            lines.append(f"> 🔧 Running: `{current_tool}`")
+            if tool_calls:
+                lines.append(f"> Tools this iteration: {', '.join(f'`{t}`' for t in tool_calls)}")
+        elif status == "completed":
+            lines.append("> ✅ _Completed_")
+
+        return "\n".join(lines)
+
+    def _process_completed_step(self, step: AgentStep) -> None:
+        """Process a completed step with full content."""
+        self._current_step_num = step.step_number
+        step_md_parts: list[str] = [f"#### Step {step.step_number}\n"]
+
+        if step.thinking:
+            step_md_parts.append(f"🧠 **Thinking:**\n\n{step.thinking}\n")
+
+        if step.accumulated_text:
+            step_md_parts.append(f"💬 **Response:**\n\n{step.accumulated_text}\n")
+
+        if step.tool_calls:
+            tool_names = [get_display_tool_name(tc.name, tc.arguments) for tc in step.tool_calls]
+            step_md_parts.append(f"**Tools:** {', '.join(tool_names)}\n")
+
+        for result in step.tool_results:
+            content = result.content
+            if result.is_error:
+                step_md_parts.append(f"**❌ {result.name} Error:** {content}\n")
+            elif len(content) > 200:
+                step_md_parts.append(
+                    f"<details><summary>📋 {result.name} result</summary>\n\n```\n{content}\n```\n</details>\n"
+                )
+            else:
+                step_md_parts.append(f"**Result ({result.name}):** {content}\n")
+
+        if step.error:
+            step_md_parts.append(f"**❌ Error:** {step.error}\n")
+
+        self.current_step_markdown = "\n".join(step_md_parts)
+        self.completed_steps_markdown.append(self.current_step_markdown)
+        self.current_step_markdown = ""
+
+        if step.is_final and step.final_answer is not None:
+            self.final_answer_text = parse_and_format_final_answer(step.final_answer)
+
+    def _render_display(self, step: AgentStep) -> None:
+        """Render the current display state."""
+        all_steps = self.completed_steps_markdown.copy()
+        if self.current_step_markdown:
+            all_steps.append(self.current_step_markdown)
+
+        display_md = "\n\n".join(all_steps)
+
+        if step.is_streaming and not step.thinking and step.accumulated_text is None:
+            display_md += "\n\n⏳ _Extended thinking in progress..._"
+        elif self.final_answer_text is None and not step.is_final:
+            display_md += "\n\n⏳ _Processing..._"
+        elif self.final_answer_text is not None:
+            display_md += f"\n\n---\n\n### ✅ Final Answer\n\n{self.final_answer_text}"
+        elif step.error:
+            display_md += f"\n\n---\n\n### ❌ Error\n\n{step.error}"
+
+        self.output_placeholder.markdown(display_md, unsafe_allow_html=True)

rossum_agent/tools/__init__.py

@@ -0,0 +1,214 @@
+"""Tools for the Rossum Agent.
+
+This package provides local tools executed directly by the agent (file operations, debugging, skills, etc.).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rossum_agent.tools.core import (
+    SubAgentProgress,
+    SubAgentProgressCallback,
+    SubAgentText,
+    SubAgentTextCallback,
+    SubAgentTokenCallback,
+    SubAgentTokenUsage,
+    get_mcp_connection,
+    get_mcp_event_loop,
+    get_output_dir,
+    get_rossum_credentials,
+    report_progress,
+    report_text,
+    report_token_usage,
+    require_rossum_credentials,
+    set_mcp_connection,
+    set_output_dir,
+    set_progress_callback,
+    set_rossum_credentials,
+    set_text_callback,
+    set_token_callback,
+)
+from rossum_agent.tools.deploy import (
+    DEPLOY_TOOLS,
+    create_workspace,
+    deploy_compare_workspaces,
+    deploy_copy_org,
+    deploy_copy_workspace,
+    deploy_diff,
+    deploy_pull,
+    deploy_push,
+    deploy_to_org,
+    get_deploy_tool_names,
+    get_deploy_tools,
+)
+from rossum_agent.tools.dynamic_tools import (
+    DISCOVERY_TOOL_NAME,
+    CatalogData,
+    DynamicToolsState,
+    get_destructive_tools,
+    get_dynamic_tools,
+    get_load_tool_category_definition,
+    get_load_tool_definition,
+    get_loaded_categories,
+    load_tool,
+    load_tool_category,
+    preload_categories_for_request,
+    reset_dynamic_tools,
+    suggest_categories_for_request,
+)
+from rossum_agent.tools.file_tools import write_file
+from rossum_agent.tools.formula import suggest_formula_field
+from rossum_agent.tools.skills import load_skill
+from rossum_agent.tools.spawn_mcp import (
+    SpawnedConnection,
+    call_on_connection,
+    cleanup_all_spawned_connections,
+    clear_spawned_connections,
+    close_connection,
+    spawn_mcp_connection,
+)
+from rossum_agent.tools.subagents import (
+    OPUS_MODEL_ID,
+    WebSearchError,
+    debug_hook,
+    evaluate_python_hook,
+    patch_schema_with_subagent,
+    search_knowledge_base,
+)
+
+if TYPE_CHECKING:
+    from anthropic._tools import BetaTool  # ty: ignore[unresolved-import] - private API
+    from anthropic.types import ToolParam
+
+_BETA_TOOLS: list[BetaTool[..., str]] = [
+    write_file,
+    search_knowledge_base,
+    evaluate_python_hook,
+    debug_hook,
+    patch_schema_with_subagent,
+    suggest_formula_field,
+    load_skill,
+    spawn_mcp_connection,
+    call_on_connection,
+    close_connection,
+]
+
+
+def get_internal_tools() -> list[ToolParam]:
+    """Get all internal tools in Anthropic format."""
+    return [tool.to_dict() for tool in _BETA_TOOLS] + [get_load_tool_category_definition(), get_load_tool_definition()]
+
+
+def get_internal_tool_names() -> set[str]:
+    """Get the names of all internal tools."""
+    return {tool.name for tool in _BETA_TOOLS} | {"load_tool_category", "load_tool"}
+
+
+def execute_internal_tool(name: str, arguments: dict[str, object]) -> str:
+    """Execute an internal tool by name.
+
+    Args:
+        name: The name of the tool to execute.
+        arguments: The arguments to pass to the tool.
+
+    Returns:
+        The result of the tool execution as a string.
+
+    Raises:
+        ValueError: If the tool name is not recognized.
+    """
+    if name == "load_tool_category":
+        raw_categories = arguments.get("categories", [])
+        categories = [str(c) for c in raw_categories] if isinstance(raw_categories, list) else [str(raw_categories)]
+        return load_tool_category(categories)
+
+    if name == "load_tool":
+        raw_tool_names = arguments.get("tool_names", [])
+        tool_names = [str(t) for t in raw_tool_names] if isinstance(raw_tool_names, list) else [str(raw_tool_names)]
+        return load_tool(tool_names)
+
+    for tool in _BETA_TOOLS:
+        if tool.name == name:
+            result: str = tool(**arguments)
+            return result
+
+    raise ValueError(f"Unknown internal tool: {name}")
+
+
+def execute_tool(name: str, arguments: dict[str, object], tools: list[BetaTool[..., str]]) -> str:
+    """Execute a tool by name from the given tool set."""
+    for tool in tools:
+        if tool.name == name:
+            return tool(**arguments)
+    raise ValueError(f"Unknown tool: {name}")
+
+
+INTERNAL_TOOLS = _BETA_TOOLS
+
+__all__ = [
+    "DEPLOY_TOOLS",
+    "DISCOVERY_TOOL_NAME",
+    "INTERNAL_TOOLS",
+    "OPUS_MODEL_ID",
+    "CatalogData",
+    "DynamicToolsState",
+    "SpawnedConnection",
+    "SubAgentProgress",
+    "SubAgentProgressCallback",
+    "SubAgentText",
+    "SubAgentTextCallback",
+    "SubAgentTokenCallback",
+    "SubAgentTokenUsage",
+    "WebSearchError",
+    "call_on_connection",
+    "cleanup_all_spawned_connections",
+    "clear_spawned_connections",
+    "close_connection",
+    "create_workspace",
+    "debug_hook",
+    "deploy_compare_workspaces",
+    "deploy_copy_org",
+    "deploy_copy_workspace",
+    "deploy_diff",
+    "deploy_pull",
+    "deploy_push",
+    "deploy_to_org",
+    "evaluate_python_hook",
+    "execute_internal_tool",
+    "execute_tool",
+    "get_deploy_tool_names",
+    "get_deploy_tools",
+    "get_destructive_tools",
+    "get_dynamic_tools",
+    "get_internal_tool_names",
+    "get_internal_tools",
+    "get_load_tool_category_definition",
+    "get_load_tool_definition",
+    "get_loaded_categories",
+    "get_mcp_connection",
+    "get_mcp_event_loop",
+    "get_output_dir",
+    "get_rossum_credentials",
+    "load_skill",
+    "load_tool",
+    "load_tool_category",
+    "patch_schema_with_subagent",
+    "preload_categories_for_request",
+    "report_progress",
+    "report_text",
+    "report_token_usage",
+    "require_rossum_credentials",
+    "reset_dynamic_tools",
+    "search_knowledge_base",
+    "set_mcp_connection",
+    "set_output_dir",
+    "set_progress_callback",
+    "set_rossum_credentials",
+    "set_text_callback",
+    "set_token_callback",
+    "spawn_mcp_connection",
+    "suggest_categories_for_request",
+    "suggest_formula_field",
+    "write_file",
+]