tsugite-cli 0.8.2__tar.gz → 0.9.3__tar.gz

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.8.2
+Version: 0.9.3
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -245,7 +245,7 @@ Requires-Dist: ddgs>=9.6.0
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: httpx>=0.25
 Requires-Dist: jinja2>=3.1
-Requires-Dist: litellm>=1.77.7
+Requires-Dist: litellm<1.82.7,>=1.77.7
 Requires-Dist: mcp>=1.0
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: pathspec>=0.11.0

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.8.2"
+version = "0.9.3"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -18,7 +18,7 @@ dependencies = [
   "questionary>=2.1.1",
   "youtube-transcript-api>=0.6.0",
   "html2text>=2020.1.16",
-  "litellm>=1.77.7",
+  "litellm>=1.77.7,<1.82.7",       # pinned: 1.82.7+ compromised (supply chain attack 2026-03-24)
   "nest-asyncio>=1.6.0",
   "pydantic>=2.12.3",
   "pathspec>=0.11.0",

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tests/test_discord_progress.py

@@ -21,6 +21,7 @@ from tsugite.events import (  # noqa: E402
     CodeExecutionEvent,
     ErrorEvent,
     FinalAnswerEvent,
+    InfoEvent,
     ObservationEvent,
     ReasoningContentEvent,
     StepStartEvent,
@@ -222,6 +223,30 @@ async def test_progress_handler_summary():
     assert "✅ Done (3 turns)" in content
 
 
+@pytest.mark.asyncio
+async def test_progress_handler_info_event():
+    """Test InfoEvent sends standalone message to channel."""
+    channel = MockChannel()
+    handler = DiscordProgressHandler(channel, asyncio.get_running_loop())
+
+    await handler._handle_event_async(StepStartEvent(step=1, max_turns=10))
+    assert len(channel.messages) == 1  # progress message
+
+    await handler._handle_event_async(InfoEvent(message="Processing step 1 of 5..."))
+    assert len(channel.messages) == 2  # progress + info message
+    assert channel.messages[1].content == "Processing step 1 of 5..."
+
+
+@pytest.mark.asyncio
+async def test_progress_handler_info_event_empty():
+    """Test empty InfoEvent is silently ignored."""
+    channel = MockChannel()
+    handler = DiscordProgressHandler(channel, asyncio.get_running_loop())
+
+    await handler._handle_event_async(InfoEvent(message=""))
+    assert len(channel.messages) == 0
+
+
 class TestCodeBlockChunking:
     """Tests for code block aware message chunking."""
 

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tests/test_history_integration.py

@@ -464,3 +464,177 @@ class TestBuildTurnMessages:
         assistant_msgs = [m for m in messages if m["role"] == "assistant"]
         code_msg = assistant_msgs[0]["content"]
         assert code_msg == "```python\nx = 1\n```"
+
+
+class TestSessionStatus:
+    """Tests for session status recording."""
+
+    def test_save_run_records_success_status(self, tmp_path, sample_agent_file):
+        with (
+            patch("tsugite.config.load_config") as mock_config,
+            patch("tsugite.history.storage.get_history_dir", return_value=tmp_path),
+            patch("tsugite.history.storage.get_machine_name", return_value="test_machine"),
+            patch("tsugite.md_agents.parse_agent_file") as mock_parse,
+        ):
+            mock_config.return_value = MagicMock(history_enabled=True)
+            mock_agent = MagicMock()
+            mock_agent.config = MagicMock(disable_history=False)
+            mock_parse.return_value = mock_agent
+
+            conv_id = save_run_to_history(
+                agent_path=sample_agent_file,
+                agent_name="test_agent",
+                prompt="test prompt",
+                result="test result",
+                model="openai:gpt-4o",
+                status="success",
+            )
+
+            from tsugite.history import SessionStorage
+
+            storage = SessionStorage.load(tmp_path / f"{conv_id}.jsonl")
+            assert storage.status == "success"
+            assert storage.error_message is None
+
+    def test_save_run_records_error_status(self, tmp_path, sample_agent_file):
+        with (
+            patch("tsugite.config.load_config") as mock_config,
+            patch("tsugite.history.storage.get_history_dir", return_value=tmp_path),
+            patch("tsugite.history.storage.get_machine_name", return_value="test_machine"),
+            patch("tsugite.md_agents.parse_agent_file") as mock_parse,
+        ):
+            mock_config.return_value = MagicMock(history_enabled=True)
+            mock_agent = MagicMock()
+            mock_agent.config = MagicMock(disable_history=False)
+            mock_parse.return_value = mock_agent
+
+            conv_id = save_run_to_history(
+                agent_path=sample_agent_file,
+                agent_name="test_agent",
+                prompt="test prompt",
+                result="",
+                model="openai:gpt-4o",
+                status="error",
+                error_message="Connection timeout",
+            )
+
+            from tsugite.history import SessionStorage
+
+            storage = SessionStorage.load(tmp_path / f"{conv_id}.jsonl")
+            assert storage.status == "error"
+            assert storage.error_message == "Connection timeout"
+
+    def test_save_run_records_interrupted_status(self, tmp_path, sample_agent_file):
+        with (
+            patch("tsugite.config.load_config") as mock_config,
+            patch("tsugite.history.storage.get_history_dir", return_value=tmp_path),
+            patch("tsugite.history.storage.get_machine_name", return_value="test_machine"),
+            patch("tsugite.md_agents.parse_agent_file") as mock_parse,
+        ):
+            mock_config.return_value = MagicMock(history_enabled=True)
+            mock_agent = MagicMock()
+            mock_agent.config = MagicMock(disable_history=False)
+            mock_parse.return_value = mock_agent
+
+            conv_id = save_run_to_history(
+                agent_path=sample_agent_file,
+                agent_name="test_agent",
+                prompt="test prompt",
+                result="",
+                model="openai:gpt-4o",
+                status="interrupted",
+            )
+
+            from tsugite.history import SessionStorage
+
+            storage = SessionStorage.load(tmp_path / f"{conv_id}.jsonl")
+            assert storage.status == "interrupted"
+
+    def test_default_status_is_success(self, tmp_path, sample_agent_file):
+        with (
+            patch("tsugite.config.load_config") as mock_config,
+            patch("tsugite.history.storage.get_history_dir", return_value=tmp_path),
+            patch("tsugite.history.storage.get_machine_name", return_value="test_machine"),
+            patch("tsugite.md_agents.parse_agent_file") as mock_parse,
+        ):
+            mock_config.return_value = MagicMock(history_enabled=True)
+            mock_agent = MagicMock()
+            mock_agent.config = MagicMock(disable_history=False)
+            mock_parse.return_value = mock_agent
+
+            conv_id = save_run_to_history(
+                agent_path=sample_agent_file,
+                agent_name="test_agent",
+                prompt="test prompt",
+                result="test result",
+                model="openai:gpt-4o",
+            )
+
+            from tsugite.history import SessionStorage
+
+            storage = SessionStorage.load(tmp_path / f"{conv_id}.jsonl")
+            assert storage.status == "success"
+
+
+class TestSessionStorageAggregates:
+    """Tests for aggregated storage properties (duration, functions)."""
+
+    def test_total_duration_ms(self, tmp_path):
+        from tsugite.history import SessionStorage
+
+        with patch("tsugite.history.storage.get_machine_name", return_value="test"):
+            storage = SessionStorage.create("agent", "model", session_path=tmp_path / "test.jsonl")
+            storage.record_turn(
+                messages=[{"role": "user", "content": "hi"}],
+                final_answer="hello",
+                duration_ms=1500,
+            )
+            storage.record_turn(
+                messages=[{"role": "user", "content": "bye"}],
+                final_answer="goodbye",
+                duration_ms=2500,
+            )
+            assert storage.total_duration_ms == 4000
+
+    def test_all_functions_called(self, tmp_path):
+        from tsugite.history import SessionStorage
+
+        with patch("tsugite.history.storage.get_machine_name", return_value="test"):
+            storage = SessionStorage.create("agent", "model", session_path=tmp_path / "test.jsonl")
+            storage.record_turn(
+                messages=[{"role": "user", "content": "hi"}],
+                functions_called=["read_file", "write_file"],
+            )
+            storage.record_turn(
+                messages=[{"role": "user", "content": "bye"}],
+                functions_called=["web_search", "read_file"],
+            )
+            assert storage.all_functions_called == ["read_file", "web_search", "write_file"]
+
+    def test_old_sessions_have_unknown_status(self, tmp_path):
+        from tsugite.history import SessionStorage
+
+        with patch("tsugite.history.storage.get_machine_name", return_value="test"):
+            storage = SessionStorage.create("agent", "model", session_path=tmp_path / "test.jsonl")
+            storage.record_turn(
+                messages=[{"role": "user", "content": "hi"}],
+                final_answer="hello",
+            )
+            # No record_status call - simulates old session
+            reloaded = SessionStorage.load(tmp_path / "test.jsonl")
+            assert reloaded.status is None
+
+    def test_load_meta_fast(self, tmp_path):
+        from tsugite.history import SessionStorage
+
+        with patch("tsugite.history.storage.get_machine_name", return_value="test"):
+            storage = SessionStorage.create("my_agent", "my_model", session_path=tmp_path / "test.jsonl")
+            storage.record_turn(
+                messages=[{"role": "user", "content": "hi"}],
+                final_answer="hello",
+            )
+
+        meta = SessionStorage.load_meta_fast(tmp_path / "test.jsonl")
+        assert meta is not None
+        assert meta.agent == "my_agent"
+        assert meta.model == "my_model"

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tests/test_history_tools.py

@@ -32,6 +32,10 @@ def mock_storage():
     storage.turn_count = 2
     storage.total_tokens = 200
     storage.total_cost = 0.004
+    storage.total_duration_ms = 0
+    storage.all_functions_called = ["read_file"]
+    storage.status = "success"
+    storage.error_message = None
 
     turn1 = Turn(
         timestamp=datetime(2025, 11, 10, 12, 0, 5, tzinfo=timezone.utc),
@@ -79,6 +83,10 @@ def mock_storage_list():
     storage1.turn_count = 2
     storage1.total_tokens = 200
     storage1.total_cost = 0.004
+    storage1.total_duration_ms = 0
+    storage1.all_functions_called = []
+    storage1.status = "success"
+    storage1.error_message = None
     storages.append(storage1)
 
     storage2 = MagicMock(spec=SessionStorage)
@@ -90,6 +98,10 @@ def mock_storage_list():
     storage2.turn_count = 5
     storage2.total_tokens = 1000
     storage2.total_cost = 0.02
+    storage2.total_duration_ms = 0
+    storage2.all_functions_called = []
+    storage2.status = "success"
+    storage2.error_message = None
     storages.append(storage2)
 
     return storages
@@ -222,6 +234,13 @@ def test_read_conversation_with_missing_optional_fields(history_tools):
     storage.model = "openai:gpt-4o-mini"
     storage.machine = "test-machine"
     storage.created_at = datetime(2025, 11, 10, 12, 0, 0, tzinfo=timezone.utc)
+    storage.turn_count = 1
+    storage.total_tokens = 0
+    storage.total_cost = 0.0
+    storage.total_duration_ms = 0
+    storage.all_functions_called = []
+    storage.status = None
+    storage.error_message = None
 
     turn = Turn(
         timestamp=datetime(2025, 11, 10, 12, 0, 5, tzinfo=timezone.utc),

tsugite_cli-0.9.3/tests/test_session_orchestrator_tools.py

@@ -0,0 +1,150 @@
+"""Tests for new session tools: session_events_since, session_summary, updated_since filter."""
+
+import json
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+import pytest
+
+from tsugite.daemon.session_store import (
+    Session,
+    SessionSource,
+    SessionStatus,
+    SessionStore,
+)
+
+
+@pytest.fixture
+def store(tmp_path):
+    store_path = tmp_path / "session_store.json"
+    return SessionStore(store_path)
+
+
+@pytest.fixture
+def session_with_events(store):
+    """Create a session and add some events to it."""
+    session = Session(
+        id="test-session-1",
+        agent="odyn",
+        source=SessionSource.BACKGROUND.value,
+        status=SessionStatus.COMPLETED.value,
+        prompt="Do something useful",
+        result="Done doing something useful",
+    )
+    store.create_session(session)
+
+    # Add events with increasing timestamps
+    base = datetime(2026, 3, 15, 10, 0, 0, tzinfo=timezone.utc)
+    events = [
+        {"type": "session_start", "timestamp": (base).isoformat(), "agent": "odyn", "prompt": "Do something"},
+        {"type": "tool_call", "timestamp": (base + timedelta(seconds=10)).isoformat(), "name": "read_file"},
+        {"type": "tool_call", "timestamp": (base + timedelta(seconds=20)).isoformat(), "name": "write_file"},
+        {"type": "tool_call", "timestamp": (base + timedelta(seconds=30)).isoformat(), "name": "read_file"},
+        {"type": "session_complete", "timestamp": (base + timedelta(seconds=40)).isoformat(), "result_preview": "Done"},
+    ]
+    for event in events:
+        store.append_event("test-session-1", event)
+
+    return session, events, base
+
+
+class TestUpdatedSinceFilter:
+    def test_list_sessions_no_filter(self, store):
+        s1 = Session(id="s1", agent="a", last_active="2026-03-15T10:00:00+00:00")
+        s2 = Session(id="s2", agent="a", last_active="2026-03-15T12:00:00+00:00")
+        store.create_session(s1)
+        store.create_session(s2)
+
+        result = store.list_sessions()
+        assert len(result) == 2
+
+    def test_list_sessions_updated_since(self, store):
+        s1 = Session(id="s1", agent="a", last_active="2026-03-15T10:00:00+00:00")
+        s2 = Session(id="s2", agent="a", last_active="2026-03-15T12:00:00+00:00")
+        s3 = Session(id="s3", agent="a", last_active="2026-03-15T14:00:00+00:00")
+        store.create_session(s1)
+        store.create_session(s2)
+        store.create_session(s3)
+
+        result = store.list_sessions(updated_since="2026-03-15T11:00:00+00:00")
+        ids = {s.id for s in result}
+        assert ids == {"s2", "s3"}
+
+    def test_list_sessions_updated_since_none_match(self, store):
+        s1 = Session(id="s1", agent="a", last_active="2026-03-15T10:00:00+00:00")
+        store.create_session(s1)
+
+        result = store.list_sessions(updated_since="2026-03-15T23:00:00+00:00")
+        assert len(result) == 0
+
+    def test_list_sessions_updated_since_combined_with_status(self, store):
+        s1 = Session(id="s1", agent="a", status="completed", last_active="2026-03-15T12:00:00+00:00")
+        s2 = Session(id="s2", agent="a", status="running", last_active="2026-03-15T12:00:00+00:00")
+        store.create_session(s1)
+        store.create_session(s2)
+
+        result = store.list_sessions(updated_since="2026-03-15T11:00:00+00:00", status="completed")
+        assert len(result) == 1
+        assert result[0].id == "s1"
+
+
+class TestSessionEventsSince:
+    def test_all_events(self, store, session_with_events):
+        _, events, _ = session_with_events
+        result = store.session_events_since("test-session-1")
+        assert len(result) == 5
+
+    def test_events_since_timestamp(self, store, session_with_events):
+        _, events, base = session_with_events
+        since = (base + timedelta(seconds=15)).isoformat()
+        result = store.session_events_since("test-session-1", since=since)
+        assert len(result) == 3  # 20s, 30s, 40s events
+        assert result[0]["type"] == "tool_call"
+        assert result[-1]["type"] == "session_complete"
+
+    def test_events_since_future(self, store, session_with_events):
+        result = store.session_events_since("test-session-1", since="2099-01-01T00:00:00+00:00")
+        assert len(result) == 0
+
+    def test_events_nonexistent_session(self, store):
+        # read_events returns [] for missing sessions, so this should work
+        result = store.session_events_since("nonexistent")
+        assert result == []
+
+
+class TestSessionSummary:
+    def test_basic_summary(self, store, session_with_events):
+        session, _, _ = session_with_events
+        summary = store.session_summary("test-session-1")
+
+        assert summary["id"] == "test-session-1"
+        assert summary["agent"] == "odyn"
+        assert summary["source"] == "background"
+        assert summary["status"] == "completed"
+        assert "Do something useful" in summary["prompt"]
+        assert "Done doing something useful" in summary["result"]
+        assert summary["event_count"] == 5
+        assert sorted(summary["tools_used"]) == ["read_file", "write_file"]
+
+    def test_summary_no_events(self, store):
+        session = Session(id="empty-session", agent="test", source="background", prompt="test")
+        store.create_session(session)
+
+        summary = store.session_summary("empty-session")
+        assert summary["event_count"] == 0
+        assert summary["tools_used"] == []
+
+    def test_summary_with_error(self, store):
+        session = Session(
+            id="error-session", agent="test", source="background",
+            status="failed", prompt="fail task", error="Something broke",
+        )
+        store.create_session(session)
+
+        summary = store.session_summary("error-session")
+        assert summary["status"] == "failed"
+        assert summary["error"] == "Something broke"
+
+    def test_summary_nonexistent_raises(self, store):
+        with pytest.raises(ValueError):
+            store.session_summary("nonexistent")

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tsugite/agent_runner/history_integration.py

@@ -78,6 +78,8 @@ def save_run_to_history(
     duration_ms: Optional[int] = None,
     claude_code_session_id: Optional[str] = None,
     claude_code_compacted: bool = False,
+    status: str = "success",
+    error_message: Optional[str] = None,
 ) -> Optional[str]:
     """Save a single agent run to history.
 
@@ -169,6 +171,8 @@ def save_run_to_history(
             metadata=metadata or None,
         )
 
+        storage.record_status(status, error_message)
+
         return storage.session_id
 
     except Exception as e:
@@ -241,16 +245,27 @@ def get_claude_code_session_info(conversation_id: str) -> Optional["ClaudeCodeSe
         storage = SessionStorage(session_path)
         records = storage.load_records()
 
-        # Single reversed pass: find the last Turn with a session ID,
-        # but bail if we hit a CompactionSummary (stale Claude Code session)
-        for record in reversed(records):
+        # Find the last CompactionSummary index (if any).
+        # Session IDs from retained turns (carried over from pre-compaction)
+        # are stale, but session IDs from turns AFTER the compaction are valid.
+        compaction_idx = -1
+        for i, record in enumerate(records):
             if isinstance(record, CompactionSummary):
-                return None
+                compaction_idx = i
+
+        for record in reversed(records):
             if isinstance(record, Turn) and record.metadata:
                 session_id = record.metadata.get("claude_code_session_id")
-                if session_id:
-                    compacted = record.metadata.get("claude_code_compacted", False)
-                    return ClaudeCodeSessionInfo(session_id, compacted)
+                if not session_id:
+                    continue
+                # If this turn is a retained turn from before compaction
+                # (carried over with stale session ID), skip it
+                if compaction_idx >= 0:
+                    turn_idx = records.index(record)
+                    if turn_idx <= compaction_idx:
+                        continue
+                compacted = record.metadata.get("claude_code_compacted", False)
+                return ClaudeCodeSessionInfo(session_id, compacted)
         return None
     except Exception:
         return None

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tsugite/agent_runner/runner.py

@@ -1,7 +1,10 @@
 """Agent execution engine using TsugiteAgent."""
 
 import asyncio
+import logging
 import time
+
+logger = logging.getLogger(__name__)
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
@@ -417,6 +420,13 @@ async def _execute_agent_with_prompt(
     if os.environ.get("TSUGITE_SUBAGENT_MODE") == "1":
         tools = [t for t in tools if t.name not in ["ask_user", "ask_user_batch"]]
 
+    # Filter out interactive_only tools when no UI handler (e.g. scheduled tasks)
+    if not ui_handler:
+        from tsugite.tools import get_interactive_only_names
+
+        interactive_names = get_interactive_only_names()
+        tools = [t for t in tools if t.name not in interactive_names]
+
     # Register per-agent custom shell tools (if any)
     if agent_config.custom_tools:
         from tsugite.shell_tool_config import parse_tool_definition_from_dict
@@ -779,6 +789,9 @@ async def run_agent_async(
         if session_info:
             claude_code_resume_session = session_info.session_id
             claude_code_resume_after_compaction = session_info.compacted
+            logger.info("Resuming Claude Code session %s (compacted=%s)", claude_code_resume_session, claude_code_resume_after_compaction)
+        else:
+            logger.debug("No Claude Code session to resume for %s", continue_conversation_id)
 
         if not claude_code_resume_session:
             # No Claude Code session to resume -- load history for serialization
@@ -838,7 +851,7 @@ async def run_agent_async(
             )
         except (RuntimeError, AgentExecutionError) as e:
             err_str = str(e).lower()
-            if claude_code_resume_session and ("process ended" in err_str or "no conversation found" in err_str):
+            if claude_code_resume_session and ("process ended" in err_str or "no conversation found" in err_str or "prompt too long" in err_str):
                 logger.warning("Claude Code resume failed (%s), retrying with full history", e)
                 try:
                     previous_messages = load_and_apply_history(continue_conversation_id)

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tsugite/builtin_agents/default.md

@@ -23,6 +23,7 @@ tools:
   - list_available_skills
   - final_answer
   - send_message
+  - react_to_message
   - web_search
   - fetch_text
   - http_request

{tsugite_cli-0.8.2 → tsugite_cli-0.9.3}/tsugite/builtin_skills/response_patterns.md

@@ -1,6 +1,6 @@
 ---
 name: response_patterns
-description: How to respond effectively - when to use print/send_message/final_answer/ask_user
+description: How to respond effectively - when to use print/send_message/react_to_message/final_answer/ask_user
 ---
 
 # Response Patterns
@@ -11,6 +11,7 @@ description: How to respond effectively - when to use print/send_message/final_a
 |----------|----------|-----------|---------|
 | `print(x)` | You (next turn) | Continues | Intermediate data |
 | `send_message(msg)` | User | Continues | Progress updates |
+| `react_to_message(emoji)` | User | Continues | Emoji acknowledgment |
 | `final_answer(msg)` | User | **Stops** | Final response |
 | `ask_user(q)` | User | **Blocks** | Get user input |
 
@@ -27,6 +28,17 @@ More examples:
 - "What's 2+2?" → `final_answer("4")`
 - "What can you do?" → `final_answer("I can read/write files, run commands, search code, and help with tasks.")`
 
+## Reactions
+
+Acknowledge messages with emoji instead of (or before) a text response:
+
+```python
+react_to_message("👍")  # React to the most recent user message
+react_to_message("✅")  # Checkmark when task is done
+```
+
+Use reactions for lightweight acknowledgment — when a thumbs-up says enough and a text reply would be noise. You can react and still send a text response, or react and call `final_answer("")` for reaction-only.
+
 ## Progress Updates
 
 For longer tasks, keep user informed:
@@ -88,6 +100,7 @@ Use `ask_user` when:
 
 ✅ Do:
 - `final_answer()` immediately for simple responses
+- `react_to_message()` for quick acknowledgment (👍, ✅, 👀)
 - `send_message()` for progress on tasks > 5 seconds
 - `ask_user()` when you genuinely need user input
 - `print()` only for data YOU need to see