tsugite-cli 0.24.0__tar.gz → 0.24.1__tar.gz

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.24.0
+Version: 0.24.1
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.24.0"
+version = "0.24.1"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/agent_runner/runner.py

@@ -10,7 +10,7 @@ from pathlib import Path  # noqa: E402
 from types import SimpleNamespace  # noqa: E402
 from typing import TYPE_CHECKING, Any, Dict, List, Optional  # noqa: E402
 
-from tsugite.core.agent import TsugiteAgent  # noqa: E402
+from tsugite.core.agent import NO_ACTION_MESSAGE, AgentResult, TsugiteAgent  # noqa: E402
 from tsugite.core.executor_registry import get_executor_class  # noqa: E402
 from tsugite.core.proxy import _parse_pattern  # noqa: E402
 from tsugite.core.state import session_state_path  # noqa: E402
@@ -401,6 +401,7 @@ async def _execute_agent_with_prompt(
     user_input_for_history: Optional[str] = None,
     channel_metadata: Optional[Dict[str, Any]] = None,
     usage_sink: Optional[Dict[str, Any]] = None,
+    requires_action: bool = False,
 ) -> str | AgentExecutionResult:
     """Execute agent with a prepared agent.
 
@@ -409,6 +410,9 @@ async def _execute_agent_with_prompt(
     `usage_sink`, when given, receives this call's token and cost counters. It is
     how a multi-step run collects accounting from steps that return plain
     strings.
+
+    `requires_action` makes a run that ends without executing any code raise, so a
+    step whose result feeds later steps cannot pass on a prose answer.
     """
     if exec_options is None:
         exec_options = ExecutionOptions()
@@ -615,7 +619,7 @@ async def _execute_agent_with_prompt(
             hook_vars=hook_vars,
             storage=session_storage,
             pre_llm_call=pre_llm_call_cb,
-            expects_action=(channel_metadata or {}).get("source") == "scheduler",
+            expects_action=requires_action or (channel_metadata or {}).get("source") == "scheduler",
         )
         # Set event_bus in context so tools can access it during execution
         _setup_event_context(event_bus)
@@ -666,10 +670,18 @@ async def _execute_agent_with_prompt(
         except Exception as e:
             logger.debug("Failed to record usage: %s", e)
 
+        if requires_action and agent.ended_no_action:
+            steps = result.steps if isinstance(result, AgentResult) and result.steps else []
+            raise AgentExecutionError(
+                NO_ACTION_MESSAGE,
+                execution_steps=steps,
+                token_usage=agent.total_tokens,
+                cost=agent.reported_cost,
+                step_count=len(steps),
+            )
+
         # Return appropriate format
         if exec_options.return_token_usage:
-            from tsugite.core.agent import AgentResult
-
             if isinstance(result, AgentResult):
                 step_count = len(result.steps) if result.steps else 0
                 steps_list = result.steps if result.steps else []
@@ -712,8 +724,6 @@ async def _execute_agent_with_prompt(
                     session_id=session_storage.session_id if session_storage else None,
                 )
         else:
-            from tsugite.core.agent import AgentResult
-
             if isinstance(result, AgentResult):
                 return str(result.output)
             else:
@@ -872,6 +882,7 @@ class _RunSetup:
     resume_after_compaction: bool = False
     resume_cost_baseline: float = 0.0
     conversation_id: Optional[str] = None
+    requires_action: bool = False
 
 
 def _prepare_step(agent: Any, prompt: str, context: Dict[str, Any], setup: "_RunSetup") -> "PreparedAgent":
@@ -955,6 +966,7 @@ async def _run_unit(
         model_kwargs=model_kwargs,
         injectable_vars=injectable_vars,
         usage_sink=usage_sink,
+        requires_action=setup.requires_action,
     )
 
     try:

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/agent_runner/steps.py

@@ -252,6 +252,7 @@ async def _execute_step_with_retries(
         resume_session=None,
         resume_after_compaction=False,
         resume_cost_baseline=0.0,
+        requires_action=bool(step.assign_var),
     )
     errors = []
     step_start_time = time.time()

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/attachments/agent_config.py

@@ -181,7 +181,7 @@ def _resolve_spec(
     if not resolved.exists():
         if spec.assign:
             bindings[spec.assign] = None
-        else:
+        elif not spec.optional:
             _warn_skipped(spec.path, f"not found: {resolved}")
         return
 

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/builtin_agents/default.md

@@ -6,9 +6,17 @@ extends: none
 # volatile memory last, so a change to today's memory / now.md doesn't invalidate
 # the identity files' cache. A flat list would be one block; these are three.
 attachments:
-  - [PERSONA.md, SOUL.md, USER.md, IDENTITY.md, AGENTS.md]
-  - [MEMORY.md, "memory/{{ yesterday() }}.md", "memory/{{ date_format(now(), '%Y-%m') }}.md"]
-  - ["memory/{{ today() }}.md", notes/context/now.md, NOW.md]
+  - - {path: PERSONA.md, optional: true}
+    - {path: SOUL.md, optional: true}
+    - {path: USER.md, optional: true}
+    - {path: IDENTITY.md, optional: true}
+    - {path: AGENTS.md, optional: true}
+  - - {path: MEMORY.md, optional: true}
+    - {path: "memory/{{ yesterday() }}.md", optional: true}
+    - {path: "memory/{{ date_format(datetime.now().replace(day=1) - timedelta(days=1), '%Y-%m') }}.md", optional: true}
+  - - {path: "memory/{{ today() }}.md", optional: true}
+    - {path: notes/context/now.md, optional: true}
+    - {path: NOW.md, optional: true}
 max_turns: 10
 tools:
   - spawn_agent

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/core/agent.py

@@ -72,6 +72,7 @@ def _usage_dump(usage) -> Optional[Dict[str, Any]]:
 
 
 CONTEXT_ACK = "Context loaded."
+NO_ACTION_MESSAGE = "run ended without executing any code or calling return_value()"
 
 
 def estimate_content_tokens(content) -> int:
@@ -369,8 +370,8 @@ class TsugiteAgent:
             skills: List of Skill objects for loaded skills
             previous_messages: List of previous conversation messages (user/assistant pairs)
             hook_vars: Dict of pre_message hook captured outputs (e.g. rag_context)
-            expects_action: The run exists to do work (a scheduled run). One that ends
-                without executing any code is recorded as ``no_action``, not ``success``.
+            expects_action: Set for a scheduled run or a step with ``assign=``. Ending
+                without executing any code records ``no_action`` instead of ``success``.
         """
         from tsugite.models import get_model_kwargs, get_provider_and_model
 
@@ -392,6 +393,7 @@ class TsugiteAgent:
         self.hook_vars = hook_vars or {}
         self._pre_llm_call = pre_llm_call
         self.expects_action = expects_action
+        self.ended_no_action = False
         self._resume_session = resume_session
         self._resume_after_compaction = resume_after_compaction
 
@@ -662,7 +664,8 @@ class TsugiteAgent:
                     self.event_bus.emit(WarningEvent(message=error_message, step=turn_num + 1))
             elif self.expects_action and not executed_code:
                 status = "no_action"
-                error_message = "run ended without executing any code or calling return_value()"
+                self.ended_no_action = True
+                error_message = NO_ACTION_MESSAGE
                 if self.event_bus:
                     self.event_bus.emit(WarningEvent(message=error_message, step=turn_num + 1))
             else:

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/core/executor.py

@@ -11,8 +11,10 @@ import ast
 import asyncio
 import contextlib
 import io
+import json
 import os
 import pprint
+import re
 import sys
 import threading
 import time
@@ -105,6 +107,27 @@ NAME_ERROR_NOTE = (
 )
 
 
+_UNDEFINED_NAME = re.compile(r"^NameError: name '(\w+)' is not defined")
+
+
+class BlockNameOrigins:
+    """Remembers which code block last assigned each top-level name, for the NameError hint."""
+
+    def __init__(self) -> None:
+        self._block = 0
+        self._defined_in: Dict[str, int] = {}
+
+    def record(self, error: Optional[str], variables_set: Dict[str, str]) -> Optional[str]:
+        """Count this block, then return `error` with the defining block appended when it names one."""
+        self._block += 1
+        match = _UNDEFINED_NAME.match(error or "")
+        if match and match[1] in self._defined_in:
+            name = match[1]
+            error += f" ('{name}' was defined in block {self._defined_in[name]} earlier in this run, not in this block)"
+        self._defined_in.update(dict.fromkeys(variables_set, self._block))
+        return error
+
+
 def truncate_observation(text: str, max_output_kb: int = MAX_EXECUTION_OUTPUT_KB) -> tuple[str, bool]:
     """Clip text to the observation cap, returning (text, was_truncated).
 
@@ -354,7 +377,8 @@ class LocalExecutor:
 
     WARNING: This is NOT secure! Only use for development.
 
-    Each call to ``execute()`` runs in a fresh namespace. Use the injected
+    Each call to ``execute()`` runs in a fresh namespace holding only ``re``,
+    ``json`` and ``os`` pre-imported. Use the injected
     ``state`` dict to persist values across turns; all other bindings are
     discarded when the turn ends.
 
@@ -403,6 +427,7 @@ class LocalExecutor:
         self._tool_functions: Dict[str, Callable[..., Any]] = {}
         self._sticky_injections: Dict[str, Any] = {}
         self._content_blocks: Dict[str, str] = {}
+        self._name_origins = BlockNameOrigins()
 
         target = workspace_dir
         if target is None and path_context is not None:
@@ -413,7 +438,7 @@ class LocalExecutor:
 
     def _build_turn_namespace(self) -> Dict[str, Any]:
         """Construct a fresh namespace populated with built-ins, tools, state, and sticky injections."""
-        ns: Dict[str, Any] = {}
+        ns: Dict[str, Any] = {"re": re, "json": json, "os": os}
 
         def return_value(*args, **kwargs):
             if args:
@@ -610,6 +635,7 @@ class LocalExecutor:
             self._state = rebound
 
         variables_set = self._get_new_variables(namespace_before)
+        exec_error = self._name_origins.record(exec_error, variables_set)
         state_keys = self._summarize_state_keys()
         save_error = self._save_state()
 

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/core/subprocess_executor.py

@@ -24,7 +24,7 @@ from typing import Any, Dict, List, Optional
 
 from tsugite.permissions import get_permissions, web_fetch_blocked_hosts
 
-from .executor import EXECUTOR_BUILTIN_TOOLS, ExecutionResult, LocalExecutor
+from .executor import EXECUTOR_BUILTIN_TOOLS, BlockNameOrigins, ExecutionResult, LocalExecutor
 from .state import load_state, save_state
 
 logger = logging.getLogger(__name__)
@@ -359,6 +359,7 @@ class SubprocessExecutor:
         self._tools_called: List[str] = []
         self._loaded_skills_for_turn: Dict[str, str] = {}
         self._unloaded_skills_for_turn: List[str] = []
+        self._name_origins = BlockNameOrigins()
 
         self._tmpdir = tempfile.mkdtemp(prefix="tsugite_sub_")
         self._proxy = None
@@ -471,7 +472,7 @@ RESULT_PATH = {json.dumps(result_path)}
 {"".join(tool_stubs)}
 {seed_denied_hosts}
 
-namespace = {{}}
+namespace = {{"re": re, "json": json, "os": os}}
 namespace["return_value"] = return_value
 namespace["final_answer"] = return_value  # backward-compat alias
 namespace["send_message"] = send_message
@@ -762,10 +763,11 @@ with open(RESULT_PATH, "w") as f:
                     pass
             return ExecutionResult(
                 output="",
-                error=(
+                error=self._name_origins.record(
                     f"tsu:exec exceeded its {self._exec_timeout}s wall-clock timeout and was terminated - "
                     "a tool call or loop hung. Break long work into smaller blocks, add your own timeouts "
-                    "around blocking calls, or raise TSUGITE_EXEC_TIMEOUT."
+                    "around blocking calls, or raise TSUGITE_EXEC_TIMEOUT.",
+                    {},
                 ),
                 stdout="",
                 stderr="",
@@ -793,16 +795,17 @@ with open(RESULT_PATH, "w") as f:
             except Exception as e:
                 logger.warning("Failed to reload state from subprocess: %s", e)
 
+            variables_set = result_data.get("variables_set", {})
             return ExecutionResult(
                 output=result_data.get("output", ""),
-                error=result_data.get("error"),
+                error=self._name_origins.record(result_data.get("error"), variables_set),
                 stdout=result_data.get("stdout", ""),
                 stderr=result_data.get("stderr", ""),
                 return_value=result_data.get("return_value"),
                 tools_called=result_data.get("tools_called", []),
                 tool_calls=result_data.get("tool_calls", []),
                 groups=result_data.get("groups", []),
-                variables_set=result_data.get("variables_set", {}),
+                variables_set=variables_set,
                 state_keys=result_data.get("state_keys", {}),
                 loaded_skills=self._loaded_skills_for_turn.copy(),
                 unloaded_skills=list(self._unloaded_skills_for_turn),
@@ -817,7 +820,7 @@ with open(RESULT_PATH, "w") as f:
                 pass
             return ExecutionResult(
                 output="",
-                error=f"Subprocess exited with code {proc.returncode}",
+                error=self._name_origins.record(f"Subprocess exited with code {proc.returncode}", {}),
                 stdout="",
                 stderr=stderr_output,
                 return_value=None,

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/md_agents.py

@@ -57,6 +57,7 @@ class AttachmentSpec(BaseModel):
     name: Optional[str] = None
     assign: Optional[str] = None
     attach: bool = True
+    optional: bool = False  # a missing file is skipped without a warning
     index_format: Literal["path_only", "first_line", "first_heading", "frontmatter"] = "first_heading"
     max_entries: int = 50
     # Cache tier this attachment belongs to (0 = first/most-stable block). Set by

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/providers/openai_compat.py

@@ -57,6 +57,7 @@ _OPENAI_MODELS: dict[str, ModelInfo] = {
     "openai/gpt-6-astra": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=10.0, output_cost_per_million=50.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"]),
     "openai/gpt-6-luna": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=0.1, output_cost_per_million=0.5, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
     "openai/gpt-6-sol": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=2.0, output_cost_per_million=10.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
+    "openai/gpt-6.1-sol": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=2.0, output_cost_per_million=10.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"]),
     "openai/gpt-daybreak-blue-latest": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=4.0, output_cost_per_million=20.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
     "openai/gpt-daybreak-red-latest": ModelInfo(max_input_tokens=400_000, max_output_tokens=128_000, input_cost_per_million=12.5, output_cost_per_million=75.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
     "openai/o1": ModelInfo(max_input_tokens=200_000, max_output_tokens=100_000, input_cost_per_million=15.0, output_cost_per_million=60.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high"]),

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/schemas/agent.schema.json

@@ -46,6 +46,11 @@
           "title": "Attach",
           "type": "boolean"
         },
+        "optional": {
+          "default": false,
+          "title": "Optional",
+          "type": "boolean"
+        },
         "index_format": {
           "default": "first_heading",
           "enum": [
@@ -61,6 +66,11 @@
           "default": 50,
           "title": "Max Entries",
           "type": "integer"
+        },
+        "tier": {
+          "default": 0,
+          "title": "Tier",
+          "type": "integer"
         }
       },
       "required": [

{tsugite_cli-0.24.0 → tsugite_cli-0.24.1}/tsugite/tools/schedule.py

@@ -95,6 +95,8 @@ def schedule_create(
     target_session: Optional[str] = None,
     delivery_mode: str = "existing_session",
     delivery_kind: str = "fyi",
+    target_session_on_error: Optional[str] = None,
+    delivery_mode_on_error: Optional[str] = None,
     incident_key: Optional[str] = None,
     incident_title: Optional[str] = None,
 ) -> dict:
@@ -136,6 +138,9 @@ def schedule_create(
             session, "auto" picks existing_session for fyi and new_session for needs_ack.
         delivery_kind: "fyi" (default) or "needs_ack". A needs_ack delivery flags the session as needing a reply
             and pings the configured notification channels.
+        target_session_on_error: target_session for the repeated-failure card (default: use target_session).
+            When no session resolves, the failure card goes to the notify channels.
+        delivery_mode_on_error: delivery_mode for the repeated-failure card (default: use delivery_mode).
         incident_key: Dedupe key so repeat firings of this schedule share one incident session instead of opening
             a new one each run.
         incident_title: Title for the incident session (default: "Incident: <id>").
@@ -188,6 +193,8 @@ def schedule_create(
         chain_depth=chain_depth,
         delivery_mode=delivery_mode,
         delivery_kind=delivery_kind,
+        target_session_on_error=target_session_on_error,
+        delivery_mode_on_error=delivery_mode_on_error,
         incident_key=incident_key,
         incident_title=incident_title,
     )
@@ -283,6 +290,8 @@ def schedule_update(
     target_session: Optional[str] = None,
     delivery_mode: Optional[str] = None,
     delivery_kind: Optional[str] = None,
+    target_session_on_error: Optional[str] = None,
+    delivery_mode_on_error: Optional[str] = None,
     incident_key: Optional[str] = None,
     incident_title: Optional[str] = None,
 ) -> dict:
@@ -308,6 +317,8 @@ def schedule_update(
         target_session: Routing target for the delivered result (optional). See schedule_create for legal forms. Set to empty string to clear (reverts to fallback chain).
         delivery_mode: New delivery mode (optional). See schedule_create for legal values.
         delivery_kind: New delivery kind (optional). See schedule_create for legal values.
+        target_session_on_error: New failure-card target (optional). Set to empty string to clear.
+        delivery_mode_on_error: New failure-card delivery mode (optional). Set to empty string to clear.
         incident_key: New incident dedupe key (optional). Set to empty string to clear.
         incident_title: New incident session title (optional). Set to empty string to clear.
 
@@ -347,6 +358,8 @@ def schedule_update(
         ("expires_at", expires_at),
         ("session_id", session_id),
         ("target_session", target_session),
+        ("target_session_on_error", target_session_on_error),
+        ("delivery_mode_on_error", delivery_mode_on_error),
         ("incident_key", incident_key),
         ("incident_title", incident_title),
     ]: