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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crow-cli
-Version: 0.1.25
+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.25 → 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.25 → crow_cli-0.1.26}/pyproject.toml

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

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

@@ -96,6 +96,7 @@ 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
@@ -169,6 +170,7 @@ 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])

{crow_cli-0.1.25 → 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:

{crow_cli-0.1.25 → 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)
@@ -732,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
 
@@ -755,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)
@@ -775,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:
         """

{crow_cli-0.1.25 → 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.25 → crow_cli-0.1.26}/src/crow_cli/agent/session.py

@@ -258,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":
@@ -378,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],
@@ -397,6 +437,7 @@ def make_agent_session(
         template, name="crow-default", db_uri=config.db_uri
     )
     display_tree = get_directory_tree(cwd)
+    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:
@@ -420,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},