crow-cli 0.1.24__tar.gz → 0.1.26__tar.gz

{crow_cli-0.1.24 → crow_cli-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crow-cli
-Version: 0.1.24
+Version: 0.1.26
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/crow-cli/crow-cli
 Project-URL: Repository, https://github.com/crow-cli/crow-cli
@@ -594,4 +594,4 @@ If you see errors about malformed tool call arguments:
 
 ## License
 
-Apache-2.0
+MIT

{crow_cli-0.1.24 → crow_cli-0.1.26}/README.md

@@ -570,4 +570,4 @@ If you see errors about malformed tool call arguments:
 
 ## License
 
-Apache-2.0
+MIT

{crow_cli-0.1.24 → crow_cli-0.1.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crow-cli"
-version = "0.1.24"
+version = "0.1.26"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.14"

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/configure.py

@@ -21,6 +21,7 @@ from crow_cli.agent.default import (
     SEARXNG_SETTINGS_YML,
     SYSTEM_PROMPT,
 )
+from crow_cli.agent.logger import setup_logger
 
 ENV_PATTERN = re.compile(r"\$\{([^}]+)\}")
 
@@ -95,16 +96,18 @@ class Config:
     max_retries_per_step: int = 3
     MAX_COMPACT_TOKENS: int = 190000
     MAX_TOKENS: int = 38192
+    TEMPERATURE: float = 0.6
     chunk_log: bool = False  # Write every raw chunk to JSONL for debugging
     system_prompt: str = SYSTEM_PROMPT
-
+    system_prompt_path: Path | None = None
     @property
     def log_path(self) -> str:
         return str(self.config_dir / "logs" / "crow-cli.log")
 
     def get_builtin_mcp_config(self) -> dict[str, Any]:
         """Return MCP config dict in FastMCP format."""
-        return {"mcpServers": dict(self.mcp_servers or {})}
+        cfg = {"mcpServers": dict(self.mcp_servers or {})}
+        return cfg
 
     @property
     def is_configured(self) -> bool:
@@ -114,6 +117,7 @@ class Config:
     @classmethod
     def load(cls, config_dir: Path | None = None) -> "Config":
         target_dir = get_default_config_dir(config_dir)
+        _logger = setup_logger(target_dir / "logs" / "crow-cli.log")
 
         # Write defaults if nothing exists yet
         if not (target_dir / "config.yaml").exists():
@@ -127,6 +131,7 @@ class Config:
         # If no config.yaml, return a bare Config
         config_file = target_dir / "config.yaml"
         if not config_file.exists():
+            _logger.info("No config.yaml found, returning bare Config")
             return cls(
                 config_dir=target_dir,
                 db_uri=os.getenv("DATABASE_PATH", str(target_dir / "crow.db")),
@@ -135,7 +140,9 @@ class Config:
         with open(config_file) as f:
             raw = yaml.safe_load(f) or {}
 
+        _logger.info("RAW config.yaml mcpServers: %s", raw.get("mcpServers", {}))
         parsed = resolve_env_vars(raw)
+        _logger.info("PARSED config.yaml mcpServers after resolve_env_vars: %s", parsed.get("mcpServers", {}))
 
         # Parse providers
         llm = LLMConfig()
@@ -163,16 +170,24 @@ class Config:
             ("max_retries_per_step", int),
             ("MAX_COMPACT_TOKENS", int),
             ("MAX_TOKENS", int),
+            ("TEMPERATURE", float),
         ):
             if key in parsed:
                 overrides[key] = typ(parsed[key])
         if "chunk_log" in parsed:
             overrides["chunk_log"] = bool(parsed["chunk_log"])
 
+        mcp_servers = parsed.get("mcpServers", {})
+        _logger.info("FINAL mcp_servers stored in Config: %s", mcp_servers)
+        system_prompt_path = None
+        if "system_prompt_path" in parsed:
+            system_prompt_path = Path(parsed["system_prompt_path"])
+
         return cls(
             config_dir=target_dir,
             llm=llm,
             db_uri=db_uri,
-            mcp_servers=parsed.get("mcpServers", {}),
+            mcp_servers=mcp_servers,
+            system_prompt_path=system_prompt_path,
             **overrides,
         )

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/default/defaults.py

@@ -123,7 +123,12 @@ AGENTS.md:
 * Use `AGENTS.md` under the repository root as your persistent memory for repository-specific knowledge and context.
 * Add important insights, patterns, and learnings to this file to improve future task performance.
 * This repository skill is automatically loaded for every conversation and helps maintain context across sessions.
+* You can use query_memory to access information from previous sessions.
 </MEMORY>
+
+<QUERY_MEMORY>
+When another agent finishes and you get a notification, DO NOT just sit there wondering what happened. Call `query_memory(session_id=<their_sid>, limit=1)` and actually read the damn message. That is how you know what they did. If you just need the latest answer, `limit=1` is your friend. If you need context, use `query` and `context`. I PITY THE FOOL WHO IGNORES THE CONTEXT OF PREVIOUS AGENTS.
+</QUERY_MEMORY>
 """
 
 COMPOSE_YAML = """services:
@@ -139,6 +144,18 @@ COMPOSE_YAML = """services:
     volumes:
       - ./searxng/:/etc/searxng
 
+  litellm:
+    image: ghcr.io/berriai/litellm:main-v1.82.6-nightly
+    restart: always
+    ports:
+      - ${LITELLM_PORT}:4000
+    environment:
+      - DASHSCOPE_API_KEY=${DASHSCOPE_API_KEY}
+      - LITELLM_API_KEY=${LITELLM_API_KEY}
+    volumes:
+      - ./litellm/config.yaml:/app/config.yaml
+    command: ["--config", "/app/config.yaml"]
+
 volumes:
   database_data:
     driver: local

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/llm.py

@@ -7,6 +7,7 @@ from openai import AsyncOpenAI
 
 from crow_cli.agent.configure import LLMProvider
 from logging import Logger
+from importlib.metadata import version
 
 
 
@@ -46,7 +47,7 @@ def configure_llm(
         api_key=api_key,
         base_url=base_url,
         http_client=http_client,
-        default_headers={"User-Agent": "KimiCLI/1.41.0"},
+        default_headers={"User-Agent": f"CrowCLI/{version('crow-cli')}"},
     )
     logger.info(f"USER-AGENT: {client.user_agent}") # =
     return client

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/main.py

@@ -61,6 +61,7 @@ from acp import (
     LoadSessionResponse,
     NewSessionResponse,
     PromptResponse,
+    RequestError,
     SetSessionModeResponse,
     run_agent,
     text_block,
@@ -184,6 +185,7 @@ class AcpAgent(Agent):
         self._config_values: dict[
             str, dict[str, str]
         ] = {}  # session_id -> {config_id: value}
+        self._notification_queue: list[dict] = []  # queued extension notifications
 
     def _default_model_value(self) -> str:
         model = next(iter(self._config.llm.models.values()), None)
@@ -329,6 +331,8 @@ class AcpAgent(Agent):
         #  mcp servers == tools == system prompt
         # ######################################
 
+        self._logger.info("new_session mcp_servers from ACP: %s", mcp_servers)
+
         # Use default MCP config if no servers provided
         builtin_config = self._config.get_builtin_mcp_config()
         self._logger.info("builtin_config: %s", builtin_config)
@@ -340,6 +344,7 @@ class AcpAgent(Agent):
             builtin_config=builtin_config,
             logger=self._logger,
         )
+        self._logger.info("new_session merged config from create_mcp_client_from_acp: %s", config)
         self._config.mcp_servers = config
         # CRITICAL: Use AsyncExitStack for lifecycle management
         mcp_client = await self._exit_stack.enter_async_context(mcp_client)
@@ -460,6 +465,7 @@ class AcpAgent(Agent):
 
             # Setup MCP client (same as new_session)
             # Use default config if no servers given
+            self._logger.info("LOAD_SESSION: mcp_servers from ACP: %s", mcp_servers)
             self._logger.info("LOAD_SESSION: Step 2: Getting builtin config")
             builtin_config = self._config.get_builtin_mcp_config()
             self._logger.info(
@@ -475,6 +481,7 @@ class AcpAgent(Agent):
                 builtin_config=builtin_config,
                 logger=self._logger,
             )
+            self._logger.info("LOAD_SESSION merged config: %s", config)
             self._logger.info("LOAD_SESSION: Step 3 complete: MCP client created")
 
             # CRITICAL: Use AsyncExitStack for lifecycle management
@@ -727,6 +734,12 @@ class AcpAgent(Agent):
                     elif chunk_type == "tool_args":
                         self._logger.debug("Tool args: %s", chunk["token"])
 
+                    elif chunk_type == "compaction":
+                        await self._conn.session_update(
+                            session_id=session.session_id,
+                            update=update_agent_message(text_block(chunk["token"])),
+                        )
+
                     elif chunk_type == "final_history":
                         break
 
@@ -750,7 +763,14 @@ class AcpAgent(Agent):
             return PromptResponse(stop_reason="cancelled")
         except Exception as e:
             self._session_logger.error("Error in prompt handling: %s", e, exc_info=True)
-            return PromptResponse(stop_reason="end_turn")
+            # Surface the failure as an ACP JSON-RPC error (code -32603) instead
+            # of a clean end_turn. A clean end_turn made the client think the
+            # turn finished normally and re-fire the task/nag loop — so a
+            # failing agent (e.g. LLM context overflow) got nagged thousands
+            # of times. The acp SDK serializes a raised RequestError into an
+            # error response; the client gates its task loop on that Err and
+            # broadcasts the message to the user.
+            raise RequestError.internal_error({"error": str(e)})
         finally:
             # 4. Cleanup the task reference when done
             self._prompt_tasks.pop(session_id, None)
@@ -770,7 +790,14 @@ class AcpAgent(Agent):
 
     async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
         """Handle extension notifications"""
-        self._logger.info("Extension notification: %s", method)
+        self._logger.info("Extension notification: %s with params: %s", method, params)
+        
+        # Queue _send notifications for processing
+        if method == "_send":
+            if not hasattr(self, '_notification_queue'):
+                self._notification_queue = []
+            self._notification_queue.append(params)
+            self._logger.info("Queued _send notification, queue size: %d", len(self._notification_queue))
 
     async def cleanup(self) -> None:
         """
@@ -786,7 +813,7 @@ class AcpAgent(Agent):
     async def list_sessions(
         self, cursor: str | None = None, cwd: str | None = None, **kwargs: Any
     ) -> ListSessionsResponse:
-        self._logger.info("Listing sessions for working directory: {cwd}", cwd=cwd)
+        self._logger.info("Listing sessions for working directory: %s", cwd)
         if cwd is None:
             return ListSessionsResponse(sessions=[], next_cursor=None)
         sessions_info = get_session_by_cwd(cwd, self._db_uri)

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/mcp_client.py

@@ -17,6 +17,7 @@ from crow_cli.agent.configure import Config
 
 def acp_to_fastmcp_config(
     mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio],
+    logger: Logger | None = None,
 ) -> dict[str, Any]:
     """
     Convert ACP mcp_servers to FastMCP configuration dict.
@@ -36,6 +37,8 @@ def acp_to_fastmcp_config(
         if isinstance(server, McpServerStdio):
             # Convert List[EnvVariable] to dict[str, str]
             env_dict = {e.name: e.value for e in server.env}
+            if logger:
+                logger.info("  acp_to_fastmcp_config: server '%s' env_dict=%s", server.name, env_dict)
 
             config["mcpServers"][server.name] = {
                 "transport": "stdio",
@@ -83,21 +86,29 @@ def create_mcp_client_from_acp(
     Returns:
         FastMCP Client instance (must be used with async with)
     """
+    logger.info("create_mcp_client_from_acp called")
+    logger.info("  mcp_servers param: %s", mcp_servers)
+    logger.info("  builtin_config param: %s", builtin_config)
+
     # Start with fallback config as base
     config: dict[str, Any] = (
         dict(builtin_config) if builtin_config else {"mcpServers": {}}
     )
+    logger.info("  base config after builtin: %s", config)
 
     # Convert any ACP mcp_servers and merge into config
     if mcp_servers:
-        acp_config = acp_to_fastmcp_config(mcp_servers)
+        acp_config = acp_to_fastmcp_config(mcp_servers, logger=logger)
+        logger.info("  acp_config converted: %s", acp_config)
         config["mcpServers"].update(acp_config["mcpServers"])
+        logger.info("  config after merging acp: %s", config)
 
     # Add cwd to each server config
-    for server_config in config["mcpServers"].values():
+    for name, server_config in config["mcpServers"].items():
         server_config["cwd"] = cwd
+        logger.info("  server '%s' env: %s", name, server_config.get("env"))
 
-    logger.info("  final config: %s", config)
+    logger.info("  final config (before transport): %s", config)
     if not config.get("mcpServers"):
         raise ValueError("No MCP servers defined in the config")
 

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/react.py

@@ -27,6 +27,12 @@ from crow_cli.agent.tools import (
     execute_acp_tool,
     execute_acp_write,
     execute_acp_prompt,
+    execute_orchestration_send_prompt,
+    execute_orchestration_task_read,
+    execute_orchestration_task_write,
+    execute_orchestration_task_send,
+    execute_orchestration_orchestrator_task_read,
+    execute_orchestration_orchestrator_task_write,
 )
 
 
@@ -41,6 +47,8 @@ async def send_request(
     max_tokens: int,
     max_retries: int = 3,
     retry_delay: float = 1.0,
+    temperature: float = 0.6,
+    request_log_path: str | None = None,
 ):
     """
     Send request to LLM with error handling and retry logic.
@@ -60,26 +68,45 @@ async def send_request(
         RateLimitError: If rate limit is exceeded.
         APIConnectionError: If connection to API fails.
     """
+    # Normalize messages once — deterministic, no need to redo per retry.
+    # Handles both list format (multimodal) and string format.
+    normalized_messages = []
+    for msg in session.messages:
+        normalized_msg = dict(msg)
+        content = msg.get("content")
+        # If content is a list of content blocks, keep it as-is (for multimodal)
+        # but if it's a list with only text blocks in the wrong format, fix it.
+        if isinstance(content, list):
+            normalized_msg["content"] = normalize_blocks(content)
+        normalized_messages.append(normalized_msg)
+
+    # Under --debug, dump the exact request payload (the append-only chat
+    # history + params) so immutable-history analysis can diff consecutive
+    # turns. Sits beside the response chunk log in the same chunk_log_dir.
+    if request_log_path:
+        request_payload = {
+            "model": session.model_identifier,
+            "messages": normalized_messages,
+            "tools": tools,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "parallel_tool_calls": True,
+            "stream_options": {"include_usage": True},
+        }
+        Path(request_log_path).write_text(
+            json.dumps(request_payload, ensure_ascii=False, indent=2)
+        )
+
     last_exception = None
 
     for attempt in range(max_retries):
         try:
-            # Normalize messages - handle both list format (multimodal) and string format
-            normalized_messages = []
-            for msg in session.messages:
-                normalized_msg = dict(msg)
-                content = msg.get("content")
-                # If content is a list of content blocks, keep it as-is (for multimodal)
-                # But if it's a list with only text blocks and they're in the wrong format, fix it
-                if isinstance(content, list):
-                    normalized_msg["content"] = normalize_blocks(content)
-                normalized_messages.append(normalized_msg)
-
             return await llm.chat.completions.create(
                 model=session.model_identifier,
                 messages=normalized_messages,
                 tools=tools,
                 stream=True,
+                temperature=temperature,
                 max_tokens=max_tokens,
                 parallel_tool_calls=True,
                 stream_options={"include_usage": True},  # Get usage in final chunk
@@ -468,7 +495,60 @@ async def execute_tool_calls(
                     args=arg_dict,
                     logger=logger,
                 )
-
+            elif tool_name == "send_prompt":
+                result_content = await execute_orchestration_send_prompt(
+                    conn=conn,
+                    turn_id=turn_id,
+                    agent_id=agent_id,
+                    tool_call_id=llm_tool_call_id,
+                    args=arg_dict,
+                    logger=logger,
+                )
+            elif tool_name == "task_read":
+                result_content = await execute_orchestration_task_read(
+                    conn=conn,
+                    turn_id=turn_id,
+                    agent_id=agent_id,
+                    tool_call_id=llm_tool_call_id,
+                    args=arg_dict,
+                    logger=logger,
+                )
+            elif tool_name == "task_write":
+                result_content = await execute_orchestration_task_write(
+                    conn=conn,
+                    turn_id=turn_id,
+                    agent_id=agent_id,
+                    tool_call_id=llm_tool_call_id,
+                    args=arg_dict,
+                    logger=logger,
+                )
+            elif tool_name == "task_send":
+                result_content = await execute_orchestration_task_send(
+                    conn=conn,
+                    turn_id=turn_id,
+                    agent_id=agent_id,
+                    tool_call_id=llm_tool_call_id,
+                    args=arg_dict,
+                    logger=logger,
+                )
+            elif tool_name == "orchestrator_task_read":
+                result_content = await execute_orchestration_orchestrator_task_read(
+                    conn=conn,
+                    turn_id=turn_id,
+                    agent_id=agent_id,
+                    tool_call_id=llm_tool_call_id,
+                    args=arg_dict,
+                    logger=logger,
+                )
+            elif tool_name == "orchestrator_task_write":
+                result_content = await execute_orchestration_orchestrator_task_write(
+                    conn=conn,
+                    turn_id=turn_id,
+                    agent_id=agent_id,
+                    tool_call_id=llm_tool_call_id,
+                    args=arg_dict,
+                    logger=logger,
+                )
             else:
                 result_content = await execute_acp_tool(
                     conn=conn,
@@ -541,21 +621,27 @@ async def react_loop(
     session_id = session_from_agent_id(agent_id)
     chunk_index = 0
     for turn in range(max_turns):
+        # Under --debug, log both the request payload and the response chunks
+        # for this turn into the same chunk_log_dir (sibling filenames).
+        chunk_log_path = None
+        request_log_path = None
+        if chunk_log_dir:
+            chunk_log_path = str(Path(chunk_log_dir) / f"turn-{turn_id}.jsonl")
+            request_log_path = str(Path(chunk_log_dir) / f"turn-{turn_id}-request.json")
+
         response = await send_request(
             llm,
             session,
             tools,
             config.MAX_TOKENS,
+            temperature=config.TEMPERATURE,
+            request_log_path=request_log_path,
         )
         state_accumulator = state_accumulators.get(
             session_id, {"thinking": [], "content": [], "tool_calls": {}}
         )
         thinking, content, tool_call_inputs, usage = [], [], [], None
 
-        chunk_log_path = None
-        if chunk_log_dir:
-            chunk_log_path = str(Path(chunk_log_dir) / f"turn-{turn_id}.jsonl")
-
         try:
             async for msg_type, token in process_response(
                 response, state_accumulator, chunk_log_path=chunk_log_path
@@ -607,6 +693,11 @@ async def react_loop(
         if usage and usage["total_tokens"] > config.MAX_COMPACT_TOKENS:
             logger.info("Token threshold crossed. Initiating compaction...")
 
+            yield {
+                "type": "compaction",
+                "token": f"\n\nCompaction threshold of {config.MAX_COMPACT_TOKENS} reached — compacting conversation history...\n\n",
+            }
+
             old_agent_id = agent_id
             logger.info(f"Pre-compacted session length: {len(session.messages)}")
             session = await compact(

{crow_cli-0.1.24 → crow_cli-0.1.26}/src/crow_cli/agent/session.py

@@ -66,8 +66,17 @@ def get_session_by_cwd(cwd, db_uri):
                     data = msgs[1].data
                     if isinstance(data, str):
                         data = json.loads(data)
-                    title = data.get("content", "")[:50] if data else "Untitled Chat"
-                except json.JSONDecodeError, AttributeError, TypeError:
+                    content = data.get("content", "") if data else ""
+                    # Handle content blocks (list of dicts) vs plain string
+                    if isinstance(content, list):
+                        title = "".join(
+                            block.get("text", "") for block in content if block.get("type") == "text"
+                        )[:50]
+                    else:
+                        title = str(content)[:50]
+                    if not title:
+                        title = "Untitled Chat"
+                except (json.JSONDecodeError, AttributeError, TypeError):
                     title = "Untitled Chat"
             else:
                 title = "Untitled Chat"
@@ -249,7 +258,7 @@ class AgentSession:
         model_identifier: str,
         db_uri: str = "sqlite:///crow.db",
         cwd: str = "/tmp",
-        agent_idx: int = 0,
+        agent_idx: int = 1,
         session_id: str | None = None,
         initial_messages: list[dict[str, Any]] | None = None,
     ) -> "AgentSession":
@@ -369,6 +378,46 @@ class AgentSession:
         self._model = None
 
 
+def get_skills_catalog(skills_dir: Path) -> str:
+    """Scan skills dir, parse SKILL.md frontmatter, return brief catalog."""
+    if not skills_dir.exists():
+        return ""
+    entries = []
+    for skill_dir in sorted(skills_dir.iterdir()):
+        skill_md = skill_dir / "SKILL.md"
+        if not skill_md.exists():
+            continue
+        try:
+            text = skill_md.read_text()
+            # Parse YAML frontmatter between --- markers
+            if not text.startswith("---"):
+                continue
+            end = text.index("---", 3)
+            frontmatter = text[3:end]
+            name = None
+            desc_lines = []
+            in_desc = False
+            for line in frontmatter.splitlines():
+                if line.startswith("name:"):
+                    name = line[5:].strip()
+                    in_desc = False
+                elif line.startswith("description:"):
+                    desc_lines.append(line[12:].strip())
+                    in_desc = True
+                elif in_desc and line.startswith("  "):
+                    desc_lines.append(line.strip())
+                else:
+                    in_desc = False
+            if name and desc_lines:
+                description = " ".join(desc_lines)
+                entries.append(f"- **{name}**: {description}")
+        except (ValueError, OSError):
+            continue
+    if not entries:
+        return ""
+    return "Available skills (~/.crow/skills/):\n" + "\n".join(entries)
+
+
 def make_agent_session(
     config: Config,
     tools: list[dict],
@@ -377,7 +426,9 @@ def make_agent_session(
     session_id: str | None = None,
     agent_idx: int | None = None,
 ):
-    if not config.system_prompt:
+    if config.system_prompt_path:
+        template = config.system_prompt_path.read_text()
+    elif not config.system_prompt:
         template_path = config.config_dir / "prompts" / "system_prompt.jinja2"
         template = template_path.read_text()
     else:
@@ -386,12 +437,19 @@ def make_agent_session(
         template, name="crow-default", db_uri=config.db_uri
     )
     display_tree = get_directory_tree(cwd)
-    agent_path = os.path.join(cwd, "AGENTS.md")
+    skills_catalog = get_skills_catalog(config.config_dir / "skills")
+    agent_path = os.path.join(cwd, "AGENTS.typ")
     if os.path.exists(agent_path):
         with open(agent_path, "r") as f:
             agents_content = f.read()
     else:
-        agents_content = "No AGENTS.md found"
+        # Fallback to markdown
+        agent_path = os.path.join(cwd, "AGENTS.md")
+        if os.path.exists(agent_path):
+            with open(agent_path, "r") as f:
+                agents_content = f.read()
+        else:
+            agents_content = "No AGENTS.md found"
     if session_id is None:
         session_id = get_coolname()
     if agent_idx is None:
@@ -403,6 +461,7 @@ def make_agent_session(
             "display_tree": display_tree,
             "agents_content": agents_content,
             "session_id": session_id,
+            "skills_catalog": skills_catalog,
         },
         tool_definitions=tools,
         request_params={"temperature": 0.2},