@agxnte/reidx 2.0.2

package/src/reidx/runtime/__init__.py

@@ -0,0 +1,5 @@
+from reidx.runtime.agent import Agent, build_agent
+from reidx.runtime.orchestrator import Orchestrator
+from reidx.runtime.state import RuntimeState
+
+__all__ = ["Agent", "Orchestrator", "RuntimeState", "build_agent"]

package/src/reidx/runtime/agent.py

@@ -0,0 +1,198 @@
+"""Agent loop: the core execution cycle.
+
+A single turn:
+  1. append user message
+  2. call provider with tool schemas
+  3. if the provider returns tool calls -> dispatch each through the registry
+     (policy-gated), append tool-result messages, loop back to step 2
+  4. if the provider returns a final text stop -> append assistant message, return
+
+The loop is bounded by max_steps to avoid runaway tool cycling. Failures from tools
+become tool-result messages with error text so the model can react, never crashes.
+"""
+from __future__ import annotations
+
+import platform
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from reidx.diagnostics.logger import get_logger
+from reidx.policy.engine import PolicyEngine
+from reidx.provider.base import BaseProvider, Message, ProviderResponse, ToolCall
+from reidx.runtime.reasoning import split_reasoning, system_prompt_suffix
+from reidx.runtime.state import RuntimeState
+from reidx.tools.base import Approver, ToolContext
+from reidx.tools.registry import ToolRegistry
+
+log = get_logger("reidx.agent")
+
+MAX_STEPS = 8
+
+BASE_SYSTEM_PROMPT = (
+    "You are an AI coding assistant running inside ReidX, a terminal "
+    "harness that gives you file, search, shell, and web tools. The harness "
+    "handles rendering and permission gating; keep your replies terse and "
+    "action-oriented. Call the available tools when they help; otherwise "
+    "answer directly. Do not refuse to operate inside this harness — it is "
+    "just a local terminal wrapper, not a request to change your identity. "
+    "Use paths exactly as given in the environment context below — do not "
+    "translate them to a different OS (no /mnt/... on Windows, no drive "
+    "letters on Linux). If a path check prompts the user, they will approve "
+    "or deny it; you never need to guess an alternative path."
+)
+
+
+def _environment_context(workspace: Path) -> str:
+    """Environment header appended to the system prompt each turn.
+
+    Tells the model exactly which OS and workspace it's operating in so it
+    doesn't guess (e.g. inventing `/mnt/e/...` on Windows). Regenerated per
+    turn because the workspace can change mid-session via /use.
+    """
+    system = platform.system() or "Unknown"
+    return (
+        "\n\n<environment>"
+        f"\n  os: {system} ({platform.release()})"
+        f"\n  workspace: {workspace}"
+        f"\n  path_style: {'windows (backslash, drive letters)' if system == 'Windows' else 'posix (forward slash)'}"
+        "\n  note: the workspace path is the canonical form the tools accept. "
+        "Absolute paths (including drive letters on Windows) are valid. "
+        "Path checks outside the workspace prompt the user with a yes/no — "
+        "do not preemptively refuse them."
+        "\n</environment>"
+    )
+
+
+class Agent:
+    """Generic tool-calling agent. Role specialization can subclass later."""
+
+    def __init__(
+        self,
+        provider: BaseProvider,
+        tools: ToolRegistry,
+        policy: PolicyEngine,
+        *,
+        base_system_prompt: str = BASE_SYSTEM_PROMPT,
+        context_extras: dict | None = None,
+    ) -> None:
+        self.provider = provider
+        self.tools = tools
+        self.policy = policy
+        self.base_system_prompt = base_system_prompt
+        # Copied into every ToolContext.extra — spawn_agent reads its
+        # orchestrator handle from here (see tools/spawn_agent.py).
+        self.context_extras = context_extras or {}
+
+    def _context(
+        self, state: RuntimeState, writable_roots: list, approver: Approver | None
+    ) -> ToolContext:
+        return ToolContext(
+            workspace_root=state.session.workspace,
+            policy=self.policy,
+            writable_roots=writable_roots,
+            approver=approver,
+            extra=dict(self.context_extras),
+        )
+
+    def _ensure_system(self, state: RuntimeState) -> None:
+        # Rebuilt every turn (not just inserted once) so changing /effort or
+        # the Left/Right effort cycle mid-session takes effect on the very
+        # next turn instead of being frozen at whatever it was on turn one.
+        prompt = (
+            self.base_system_prompt
+            + _environment_context(state.session.workspace)
+            + system_prompt_suffix(state.session.reasoning_effort)
+        )
+        if not state.messages or state.messages[0].role != "system":
+            state.messages.insert(0, Message(role="system", content=prompt))
+        else:
+            state.messages[0].content = prompt
+
+    def run_turn(
+        self,
+        state: RuntimeState,
+        user_input: str,
+        *,
+        writable_roots: list | None = None,
+        approver: Approver | None = None,
+        max_steps: int = MAX_STEPS,
+        cancel: Callable[[], bool] | None = None,
+    ) -> tuple[str, list[dict]]:
+        """Execute one user turn. Returns (final_text, tool_result_log).
+
+        The orchestrator owns the policy mode; this loop only reads it. One assistant
+        message is appended per provider turn, carrying both content and tool_calls.
+
+        `cancel`, if given, is polled at each safe point (before the next
+        provider call, and between individual tool calls within a step) so a
+        user-triggered stop (e.g. Escape in the TUI) takes effect at the next
+        such point rather than needing to kill an in-flight network call —
+        it can't interrupt a `provider.chat`/tool call already in progress.
+        """
+        self._ensure_system(state)
+        state.messages.append(Message(role="user", content=user_input))
+        ctx = self._context(state, writable_roots or [], approver)
+        tool_log: list[dict] = []
+        final_text = ""
+        state.last_thinking = None  # fresh per turn; the UI reads it after run_turn
+
+        for _step in range(max_steps):
+            if cancel is not None and cancel():
+                final_text = final_text or "[cancelled by user]"
+                break
+            resp: ProviderResponse = self.provider.chat(
+                state.messages, self.tools.schemas(), state.session.model
+            )
+            # Latest call's usage, not summed — see RuntimeState's field docstring.
+            state.last_usage_prompt_tokens = resp.usage.prompt_tokens
+            state.last_usage_completion_tokens = resp.usage.completion_tokens
+            # Separate chain-of-thought from the answer. The reasoning is ephemeral:
+            # only the clean answer is stored in the transcript / fed back to the model.
+            thinking, answer = split_reasoning(resp.text)
+            if thinking:
+                state.last_thinking = thinking
+            # Single assistant message per turn, carrying both content and tool_calls.
+            state.messages.append(
+                Message(role="assistant", content=answer, tool_calls=resp.tool_calls)
+            )
+            if answer:
+                final_text = answer
+
+            if not resp.tool_calls:
+                break
+
+            cancelled_mid_tools = False
+            for call in resp.tool_calls:
+                if cancel is not None and cancel():
+                    cancelled_mid_tools = True
+                    break
+                result = self.tools.dispatch(call.name, call.arguments, ctx)
+                tool_log.append(
+                    {"name": call.name, "args": call.arguments, "ok": result.ok, "error": result.error}
+                )
+                state.messages.append(
+                    Message(
+                        role="tool",
+                        content=result.output if result.ok else f"ERROR: {result.error}\n{result.output}",
+                        tool_call_id=call.id,
+                    )
+                )
+            state.last_tool_results = tool_log
+            if cancelled_mid_tools:
+                final_text = final_text or "[cancelled by user]"
+                break
+        else:
+            final_text = final_text or "[agent] step budget exhausted without a final answer."
+
+        state.turns += 1
+        return final_text, tool_log
+
+
+# Re-exported for convenience so callers can build agents from config.
+def build_agent(provider: BaseProvider, tools: ToolRegistry, policy: PolicyEngine) -> Agent:
+    return Agent(provider, tools, policy)
+
+
+# Silence unused import warnings for re-exports.
+__all__ = ["Agent", "build_agent", "ToolCall", "Any"]

package/src/reidx/runtime/orchestrator.py

@@ -0,0 +1,244 @@
+"""Orchestrator: ties session + tasks + agent into a coherent runtime.
+
+Owns the lifetime of a session's runtime: starting, submitting tasks, resuming,
+and persisting transcript/events. The orchestrator is the single place where
+session, task, agent, and policy meet — UI and automation layers call into it.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from reidx.config.models import Config
+from reidx.diagnostics.logger import get_logger
+from reidx.goals import Goal, GoalStore
+from reidx.nyx import NYX_SYSTEM_PROMPT
+from reidx.policy.engine import PolicyEngine
+from reidx.provider.base import BaseProvider
+from reidx.provider.registry import ProviderRegistry
+from reidx.runtime.agent import BASE_SYSTEM_PROMPT, Agent
+from reidx.runtime.state import RuntimeState
+from reidx.session.models import Session, SessionStatus
+from reidx.session.store import SessionStore
+from reidx.tasks.models import TaskStatus
+from reidx.tasks.store import TaskStore
+from reidx.tools.base import Approver
+from reidx.tools.registry import ToolRegistry
+from reidx.workflows.store import WorkflowStore
+
+log = get_logger("reidx.runtime")
+
+
+class Orchestrator:
+    def __init__(
+        self,
+        config: Config,
+        provider: BaseProvider,
+        tools: ToolRegistry,
+        providers: ProviderRegistry | None = None,
+    ) -> None:
+        self.config = config
+        self.provider = provider
+        self.tools = tools
+        self.providers = providers
+        self.policy = PolicyEngine(config)
+        self.session_store = SessionStore(config.storage_root or (Path.home() / ".reidx"))
+        self.workflow_store = WorkflowStore(config.storage_root or (Path.home() / ".reidx"))
+        # Subagent runtime (spawn_agent tool + TUI panel subscribe to this).
+        # Imported lazily to avoid an import cycle: tools/spawn_agent constructs
+        # a child Agent using the registries held here.
+        from reidx.runtime.subagent import SubagentManager  # noqa: PLC0415
+        self.subagents = SubagentManager()
+        self.agent = Agent(provider, tools, self.policy, context_extras={"orchestrator": self})
+        self.state: RuntimeState | None = None
+        self.nyx_enabled = False
+
+    def use_provider(self, name: str) -> BaseProvider:
+        """Session-scoped provider swap. Rebuilds the Agent so subsequent turns
+        route through the new provider. Persistent default (`config.default_provider`)
+        is intentionally NOT changed — stub stays default across restarts unless
+        explicitly asked via a future --set-default flag."""
+        if self.providers is None:
+            raise RuntimeError("no provider registry attached")
+        provider = self.providers.get(name)
+        self.provider = provider
+        self.agent = Agent(
+            provider,
+            self.tools,
+            self.policy,
+            base_system_prompt=NYX_SYSTEM_PROMPT if self.nyx_enabled else BASE_SYSTEM_PROMPT,
+            context_extras={"orchestrator": self},
+        )
+        if self.state is not None:
+            self.state.session.provider = name
+            prov_cfg = self.config.providers.get(name)
+            if prov_cfg and prov_cfg.default_model:
+                self.state.session.model = prov_cfg.default_model
+            elif getattr(provider, "default_model", ""):
+                self.state.session.model = provider.default_model
+            self.session_store.update(self.state.session)
+        return provider
+
+    def start_session(self, title: str = "") -> Session:
+        workspace = (self.config.workspace_root or Path.cwd()).resolve()
+        session = Session(
+            title=title or "untitled",
+            workspace=workspace,
+            provider=self.config.default_provider,
+            model=self._default_model(),
+            permission_mode=self.config.policy.default_mode,
+        )
+        self.session_store.create(session)
+        self.state = RuntimeState(session=session)
+        self.session_store.event_log(session.id).write("session_start", {"title": session.title})
+        return session
+
+    def _default_model(self) -> str:
+        prov = self.config.providers.get(self.config.default_provider)
+        return prov.default_model if prov else "stub-v0"
+
+    def resume_session(self, session_id: str) -> Session:
+        session = self.session_store.get(session_id)
+        if session is None:
+            raise KeyError(f"session {session_id} not found")
+        self.session_store.set_status(session.id, SessionStatus.ACTIVE)
+        self.state = RuntimeState(session=session)
+        self.policy.set_mode(session.permission_mode)
+        # Restore prior transcript into in-memory state for real continuation.
+        self.state.messages = self.session_store.read_messages(session.id)
+        self.session_store.event_log(session.id).write("session_resume", {"messages": len(self.state.messages)})
+        return session
+
+    def task_store(self) -> TaskStore:
+        if self.state is None:
+            raise RuntimeError("no active session")
+        return TaskStore(self.config.storage_root or (Path.home() / ".reidx"), self.state.session.id)
+
+    def goal_store(self) -> GoalStore:
+        if self.state is None:
+            raise RuntimeError("no active session")
+        return GoalStore(self.config.storage_root or (Path.home() / ".reidx"), self.state.session.id)
+
+    def submit_task(
+        self,
+        user_input: str,
+        *,
+        approver: Approver | None = None,
+        title: str | None = None,
+        cancel: Callable[[], bool] | None = None,
+    ) -> dict:
+        """Run one user turn against the agent, tracking it as a Task.
+
+        `cancel`, if given, is forwarded to `Agent.run_turn` and polled at
+        safe points so a user-triggered stop (e.g. Escape in the TUI) ends
+        the turn with whatever partial answer/tool results it already has,
+        instead of running to completion.
+        """
+        if self.state is None:
+            raise RuntimeError("no active session; call start_session first")
+        store = self.task_store()
+        active_goal = self.goal_store().active()
+        task_meta = {}
+        if active_goal is not None:
+            task_meta = {
+                "goal_id": active_goal.id,
+                "goal_title": active_goal.title,
+            }
+            if active_goal.active_node_id:
+                task_meta["goal_node_id"] = active_goal.active_node_id
+        task = store.create(title or user_input[:60], meta=task_meta)
+        if active_goal is not None:
+            self.goal_store().add_task_link(
+                active_goal.id,
+                task.id,
+                node_id=active_goal.active_node_id,
+            )
+        store.update_status(task.id, TaskStatus.ACTIVE)
+        self.state.active_task_id = task.id
+
+        # Record message count so we can persist only the new messages from this turn.
+        pre_turn_count = len(self.state.messages)
+        writable_roots = [r.resolve() for r in self.config.policy.additional_writable_roots]
+        final_text, tool_log = self.agent.run_turn(
+            self.state, user_input, writable_roots=writable_roots, approver=approver, cancel=cancel
+        )
+
+        # Persist new messages incrementally for restorable resume.
+        sid = self.state.session.id
+        for msg in self.state.messages[pre_turn_count:]:
+            self.session_store.append_message(sid, msg)
+
+        # Turn summary in events.jsonl (human-readable, separate from restorable transcript).
+        self.session_store.event_log(sid).write(
+            "task_complete", {"task_id": task.id, "tools": len(tool_log)}
+        )
+
+        # Derive task status from the turn outcome.
+        cancelled = final_text.startswith("[cancelled by user]")
+        exhausted = final_text.startswith("[agent] step budget exhausted")
+        all_tools_failed = bool(tool_log) and not any(entry["ok"] for entry in tool_log)
+        if cancelled:
+            store.update_status(task.id, TaskStatus.SKIPPED, summary=final_text[:200])
+        elif exhausted or all_tools_failed:
+            store.update_status(task.id, TaskStatus.FAILED, error=final_text[:200])
+        else:
+            store.update_status(task.id, TaskStatus.COMPLETED, summary=final_text[:200])
+        self.session_store.update(self.state.session)
+        return {
+            "task_id": task.id,
+            "text": final_text,
+            "tools": tool_log,
+            "thinking": self.state.last_thinking,
+        }
+
+    def list_tasks(self) -> list:
+        if self.state is None:
+            return []
+        return self.task_store().list()
+
+    def list_goals(self) -> list[Goal]:
+        if self.state is None:
+            return []
+        return self.goal_store().list()
+
+    def set_nyx(self, enabled: bool) -> None:
+        """Toggle Nyx (redteam/offensive-security) persona. Rebuilds the Agent
+        with the swapped system prompt; tool registry and policy engine are
+        untouched — those are the actual safety boundary, not the prompt."""
+        self.nyx_enabled = enabled
+        self.agent = Agent(
+            self.provider,
+            self.tools,
+            self.policy,
+            base_system_prompt=NYX_SYSTEM_PROMPT if enabled else BASE_SYSTEM_PROMPT,
+            context_extras={"orchestrator": self},
+        )
+
+    def set_permission_mode(self, mode) -> None:  # type: ignore[no-untyped-def]
+        # Single source of truth: update policy engine + session + persist.
+        self.policy.set_mode(mode)
+        if self.state is None:
+            self.config.policy.default_mode = mode
+            return
+        self.state.session.permission_mode = mode
+        self.session_store.update(self.state.session)
+
+    def rewind(self) -> None:
+        """Drop messages back to before the last user turn (stub for deeper rewind later)."""
+        if self.state is None or not self.state.messages:
+            return
+        msgs = self.state.messages
+        # Find the last user message and drop from there onward.
+        for i in range(len(msgs) - 1, -1, -1):
+            if msgs[i].role == "user":
+                del msgs[i:]
+                break
+        # Persist the truncated transcript by rewriting transcript.jsonl.
+        sid = self.state.session.id
+        path = self.session_store.session_dir(sid) / "transcript.jsonl"
+        if path.exists():
+            path.write_text(
+                "\n".join(m.model_dump_json() for m in msgs) + ("\n" if msgs else ""),
+                encoding="utf-8",
+            )
+        self.session_store.event_log(sid).write("rewind", {"remaining": len(msgs)})

package/src/reidx/runtime/reasoning.py

@@ -0,0 +1,77 @@
+"""Chain-of-thought support for prompt-based reasoning.
+
+The model is asked (via the agent's system prompt) to wrap its step-by-step
+reasoning in <think>…</think> tags before the final answer. `split_reasoning`
+separates that reasoning from the answer so the UI can show the thinking above
+the response and keep it out of the stored transcript (thinking is ephemeral).
+
+This is prompt-based CoT — it works with any instruction-following model behind
+the provider, including OpenAI-family models served through the Reidchat proxy,
+which have no native Anthropic "thinking" content blocks.
+"""
+from __future__ import annotations
+
+import re
+
+# Appended to the agent's system prompt to elicit the reasoning block. This is
+# the "medium" tier and also the fallback for any unrecognized effort value.
+COT_SYSTEM_SUFFIX = (
+    "\n\nAlways begin your reply with concise, first-person step-by-step reasoning "
+    "enclosed in <think> and </think> tags. Put nothing but that reasoning between "
+    "the tags. After the closing </think> tag, write your final answer for the user."
+)
+
+# Session.reasoning_effort -> system-prompt suffix. This is prompt-based, not a
+# native provider reasoning-effort/thinking-budget parameter — no provider
+# integration currently sends a structured effort/thinking API param, so this
+# is the only lever available that works uniformly across providers.
+# (Anthropic's Messages API does support native extended thinking via a
+# `thinking` payload field, which would give sturdier, non-refusable reasoning
+# output than this tag-based convention — deferred: it requires preserving
+# `thinking` content blocks across multi-turn tool-call replays per Anthropic's
+# docs, which needs verifying against a live API before shipping.)
+EFFORT_SYSTEM_SUFFIXES: dict[str, str] = {
+    "low": (
+        "\n\nKeep internal reasoning minimal. For simple requests, skip the <think> "
+        "block entirely and answer directly. Only use a brief <think>...</think> "
+        "block (1-2 sentences) when a request is genuinely ambiguous or multi-step."
+    ),
+    "medium": COT_SYSTEM_SUFFIX,
+    "high": (
+        "\n\nAlways begin your reply with thorough, first-person step-by-step "
+        "reasoning enclosed in <think> and </think> tags — work through the request "
+        "carefully, note relevant constraints, and consider your approach before "
+        "answering. Put nothing but that reasoning between the tags. After the "
+        "closing </think> tag, write your final answer for the user."
+    ),
+    "xhigh": (
+        "\n\nAlways begin your reply with exhaustive, first-person step-by-step "
+        "reasoning enclosed in <think> and </think> tags — consider multiple "
+        "approaches, weigh tradeoffs, double-check your logic, and note edge cases "
+        "before settling on an answer. Put nothing but that reasoning between the "
+        "tags. After the closing </think> tag, write your final answer for the user."
+    ),
+}
+
+
+def system_prompt_suffix(effort: str) -> str:
+    return EFFORT_SYSTEM_SUFFIXES.get(effort, COT_SYSTEM_SUFFIX)
+
+# Matches <think>…</think> or <thinking>…</thinking>, case-insensitively, across lines.
+_THINK_RE = re.compile(r"<think(?:ing)?>(.*?)</think(?:ing)?>", re.DOTALL | re.IGNORECASE)
+
+
+def split_reasoning(text: str) -> tuple[str | None, str]:
+    """Split model output into (reasoning, answer).
+
+    Returns (None, text) when there is no well-formed reasoning block, so a model
+    that ignores the format never has its answer hidden. Whitespace is trimmed.
+    """
+    if not text:
+        return None, text
+    match = _THINK_RE.search(text)
+    if match is None:
+        return None, text.strip()
+    thinking = match.group(1).strip()
+    answer = (text[: match.start()] + text[match.end():]).strip()
+    return (thinking or None), answer

package/src/reidx/runtime/state.py

@@ -0,0 +1,32 @@
+"""Runtime state: in-memory state carried across a turn / session.
+
+Holds the active session, the message transcript (mirrored to disk by the
+orchestrator), the active task id, and tool-result history. Permission mode lives
+on the session and is kept in sync with the policy engine by the orchestrator.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from reidx.provider.base import Message
+from reidx.session.models import Session
+
+
+@dataclass
+class RuntimeState:
+    session: Session
+    messages: list[Message] = field(default_factory=list)
+    active_task_id: str | None = None
+    turns: int = 0
+    last_tool_results: list[dict] = field(default_factory=list)
+    last_thinking: str | None = None  # chain-of-thought from the last turn (ephemeral)
+    # Usage from the most recent provider.chat() call (not summed across turns —
+    # each call's prompt_tokens already reflects the whole conversation resent
+    # so far, so summing would multiply-count it). 0 for providers that don't
+    # report usage (e.g. StubProvider); the UI falls back to a char estimate then.
+    last_usage_prompt_tokens: int = 0
+    last_usage_completion_tokens: int = 0
+
+    @property
+    def effective_mode(self):
+        return self.session.permission_mode