flowjet 2.0.7__tar.gz → 2.0.9__tar.gz

{flowjet-2.0.7 → flowjet-2.0.9}/CHANGELOG.md

@@ -10,6 +10,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.9] — 2026-09-24
+
+### Fixed
+
+- **Suppress noisy third-party warnings at startup.** `requests` emits
+  `RequestsDependencyWarning` when the installed `urllib3` / `chardet` /
+  `charset_normalizer` versions fall outside its supported range, and
+  `soothe`'s `TypeSafeClassifier` triggers LangChain's `LangChainBetaWarning`.
+  Both are version-mismatch or beta-API notices the user cannot act on, so
+  they are now silenced at the earliest point of each entry point. A new
+  `core/_warnings.py` module exposes `suppress_known_warnings()`, called from
+  both the CLI (`cli.py`) and server (`server/__main__.py`) `main()` before
+  the heavy agent stack is imported.
+
+## [2.0.8] — 2026-09-24
+
+### Added
+
+- **`ask_user` interrupt/resume in the CLI.** The nano runtime now surfaces
+  soothe's `ask_user` interrupt so the agent can pause mid-run to ask
+  structured questions and resume on a follow-up invocation. `RunRequest`
+  gains `resume_value`, which the direct and nano backends forward into
+  LangGraph's `Command(resume=...)` instead of starting a new turn.
+  `mapping.py` extracts the `ask_user` questions and interrupt ids from a
+  `__interrupt__` payload and carries them on `InterruptWaiting`; `stream.py`
+  renders the questions block (options, recommended marker, resume hint) and
+  returns an `INTERRUPTED` sentinel instead of "Done" when the graph pauses.
+  `cli.py` detects a pending `ask_user` interrupt on the thread snapshot,
+  prints the questions, and feeds the user's query text as the resume answer
+  — so `fjf -t <thread> <answer>` continues the paused run.
+
 ## [2.0.7] — 2026-09-23
 
 ### Changed

{flowjet-2.0.7 → flowjet-2.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowjet
-Version: 2.0.7
+Version: 2.0.9
 Summary: FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano
 Project-URL: Homepage, https://github.com/caesar0301/flowjet
 Project-URL: Repository, https://github.com/caesar0301/flowjet

{flowjet-2.0.7 → flowjet-2.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flowjet"
-version = "2.0.7"
+version = "2.0.9"
 description = "FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano"
 readme = "README.md"
 license = { text = "MIT" }

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/cli/cli.py

@@ -518,6 +518,37 @@ def run_pin_thread(thread_id: str) -> int:
     return 0
 
 
+async def _detect_pending_interrupt(agent: Any, thread_id: str) -> Any:
+    """Return the pending ``ask_user`` interrupt value, or ``None``.
+
+    Checks the LangGraph snapshot for the thread. When an ``ask_user``
+    interrupt is pending, its ``value`` carries the question specs; the CLI
+    can resume the run by feeding the user's answer to ``Command(resume=...)``.
+    """
+    get_state = getattr(agent, "aget_state", None)
+    if not callable(get_state):
+        return None
+    try:
+        snapshot = await get_state({"configurable": {"thread_id": thread_id}})
+    except Exception:
+        return None
+    if snapshot is None:
+        return None
+    interrupts = getattr(snapshot, "interrupts", None) or ()
+    if not interrupts:
+        # Some snapshots nest interrupts under per-task state.
+        tasks = getattr(snapshot, "tasks", None) or ()
+        for task in tasks:
+            task_interrupts = getattr(task, "interrupts", None) or ()
+            interrupts = task_interrupts
+            break
+    for entry in interrupts:
+        value = getattr(entry, "value", None)
+        if isinstance(value, dict) and value.get("type") == "ask_user":
+            return value
+    return None
+
+
 async def run_async(args: argparse.Namespace) -> int:
     conflict = validate_arg_composition(args)
     if conflict:
@@ -570,14 +601,39 @@ async def run_async(args: argparse.Namespace) -> int:
                     ask_mode=getattr(args, "ask", False),
                     bypass_mode=getattr(args, "bypass", False),
                 )
+                # If the thread paused on an ``ask_user`` interrupt, the user's
+                # query text is their answer — resume the run instead of
+                # starting a new turn. ``fjf`` (follow) hits this path when the
+                # previous run ended on a question.
+                resume_value: Any = None
+                pending = await _detect_pending_interrupt(agent, thread_id)
+                if pending is not None:
+                    from flowjet.cli.stream import format_questions_block
+
+                    questions = pending.get("questions") or ()
+                    if isinstance(questions, list):
+                        questions = tuple(q for q in questions if isinstance(q, dict))
+                    else:
+                        questions = ()
+                    # Print the questions so the user sees what they're answering.
+                    if questions:
+                        sys.stdout.write(format_questions_block(questions, thread_id))
+                        sys.stdout.flush()
+                    resume_value = {"answers": [args.query_text]}
                 if args.no_stream:
-                    await invoke_query(agent, args.query_text, thread_id=thread_id)
+                    await invoke_query(
+                        agent,
+                        args.query_text,
+                        thread_id=thread_id,
+                        resume_value=resume_value,
+                    )
                 else:
                     await stream_query(
                         agent,
                         args.query_text,
                         thread_id=thread_id,
                         show_tool_calls=args.verbose,
+                        resume_value=resume_value,
                     )
     except ConcurrentSessionError as exc:
         sys.stderr.write(f"error: {exc}\n")
@@ -661,6 +717,11 @@ def main_follow(argv: list[str] | None = None) -> int:
 
 
 def main(argv: list[str] | None = None) -> int:
+    # Silence noisy third-party warnings (requests version-mismatch,
+    # LangChain beta-API) before any heavy import pulls them in.
+    from flowjet.core._warnings import suppress_known_warnings
+
+    suppress_known_warnings()
     try:
         # Parse first so ``-V`` / ``-h`` / ``--help`` exit before we touch the
         # logging stack (and the heavy ``flowjet.cli.agent`` import it used to

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/cli/stream.py

@@ -36,6 +36,11 @@ from flowjet.core.tool_results import (
 # Min interval between live narration previews on the progress line (seconds).
 _STATUS_PREVIEW_MIN_INTERVAL = 0.12
 
+# Returned by ``stream_query`` / ``invoke_query`` when the agent paused for
+# human input (``ask_user`` interrupt) instead of completing. The CLI checks
+# for this sentinel to print the resume hint and accept an answer via ``fjf``.
+INTERRUPTED = "__FJ_INTERRUPTED__"
+
 
 def _format_duration(seconds: float) -> str:
     """Format an elapsed time as a short human-readable duration.
@@ -273,6 +278,44 @@ class AnswerWriter:
         return self.buf
 
 
+def format_questions_block(questions: tuple[dict[str, Any], ...], thread_id: str) -> str:
+    """Render ``ask_user`` questions as a terminal block with a resume hint.
+
+    The block is written to stdout after the ephemeral progress line is
+    cleared, so it stays visible. Each question lists its options with the
+    recommended one (label ending in "(Recommended)") marked. The footer
+    tells the user how to resume with an answer via ``fjf``.
+    """
+    if not questions:
+        return f"\n⏸ Paused for input · resume with: fjf -t {thread_id} <your answer>\n"
+    lines: list[str] = ["", "⏸ Paused for input:"]
+    for qi, q in enumerate(questions, 1):
+        header = str(q.get("header") or "").strip()
+        question = str(q.get("question") or "").strip()
+        if len(questions) > 1:
+            prefix = f"  Q{qi}: "
+        else:
+            prefix = "  "
+        if header:
+            lines.append(f"{prefix}[{header}] {question}")
+        else:
+            lines.append(f"{prefix}{question}")
+        options = q.get("options")
+        if isinstance(options, list):
+            for opt in options:
+                if not isinstance(opt, dict):
+                    continue
+                label = str(opt.get("label") or "").strip()
+                desc = str(opt.get("description") or "").strip()
+                marker = " ★" if "(Recommended)" in label or "Recommended" in label else ""
+                if desc:
+                    lines.append(f"      • {label}{marker} — {desc}")
+                else:
+                    lines.append(f"      • {label}{marker}")
+    lines.append(f"\n  Resume with: fjf -t {thread_id} <your answer>\n")
+    return "\n".join(lines) + "\n"
+
+
 async def stream_query(
     agent: SootheNanoAgent,
     query: str,
@@ -283,8 +326,14 @@ async def stream_query(
     out: TextIO | None = None,
     err: TextIO | None = None,
     progress: ProgressLine | None = None,
+    resume_value: Any = None,
 ) -> str:
-    """Run a query with ephemeral progress; print the complete final answer."""
+    """Run a query with ephemeral progress; print the complete final answer.
+
+    When the agent pauses for human input (``ask_user`` interrupt), the
+    questions are rendered and :data:`INTERRUPTED` is returned — the run is
+    not complete and must be resumed with ``fjf -t <thread> <answer>``.
+    """
     stdout = out or sys.stdout
     stderr = err or sys.stderr
     status = progress if progress is not None else ProgressLine(stdout)
@@ -293,6 +342,7 @@ async def stream_query(
     # ``-v``: emit each tool call once when args are available.
     mirrored_tool_ids: set[str] = set()
     started_at = time.monotonic()
+    interrupted = False
 
     # Deepagents emits a deprecation warning mid-run that would smash the
     # ephemeral progress line when mixed onto the terminal.
@@ -309,7 +359,12 @@ async def stream_query(
         async with status:
             status.update("Thinking", color="cyan")
             async for event in backend.stream_run(
-                RunRequest(model="default", input_text=query, session=thread_id)
+                RunRequest(
+                    model="default",
+                    input_text=query,
+                    session=thread_id,
+                    resume_value=resume_value,
+                )
             ):
                 if isinstance(event, Progress):
                     # ``raw`` carries the soothe-nano custom payload so the
@@ -378,7 +433,15 @@ async def stream_query(
 
                 if isinstance(event, InterruptWaiting):
                     status.update("Waiting for input…", color="yellow")
-                    if show_tool_calls:
+                    if event.questions:
+                        # A real ``ask_user`` interrupt pauses the graph —
+                        # render the questions and mark the run as interrupted
+                        # so the CLI returns ``INTERRUPTED`` instead of "Done".
+                        status.blank()
+                        stdout.write(format_questions_block(event.questions, thread_id))
+                        stdout.flush()
+                        interrupted = True
+                    elif show_tool_calls:
                         _write_verbose(
                             status,
                             stderr,
@@ -390,6 +453,10 @@ async def stream_query(
                     raise RuntimeError(event.message)
 
     answer_text = answer.finish()
+    if interrupted:
+        # The run paused for input — don't print "Done", the questions block
+        # (or generic pause message) is already on stdout.
+        return INTERRUPTED
     duration = _format_duration(time.monotonic() - started_at)
     stdout.write(f"\n✓ Done · {duration} · {thread_id}\n")
     stdout.flush()
@@ -403,6 +470,7 @@ async def invoke_query(
     thread_id: str,
     out: TextIO | None = None,
     progress: ProgressLine | None = None,
+    resume_value: Any = None,
 ) -> str:
     """Progress until done, then print the final text (no live narration preview)."""
     return await stream_query(
@@ -413,4 +481,5 @@ async def invoke_query(
         live_answer=False,
         out=out,
         progress=progress,
+        resume_value=resume_value,
     )

flowjet-2.0.9/src/flowjet/core/_warnings.py

@@ -0,0 +1,53 @@
+"""Suppress noisy third-party warnings that are not actionable for users.
+
+These warnings come from dependencies (``requests``, ``soothe``/``langchain``)
+and fire at import time or agent build time. They are version-mismatch or
+beta-API notices that the user cannot fix, so we silence them globally at the
+earliest point of each entry point (CLI ``main`` and server ``main``).
+
+Call :func:`suppress_known_warnings` before importing the heavy agent stack.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+
+def suppress_known_warnings() -> None:
+    """Silence dependency warnings that users cannot act on.
+
+    Safe to call multiple times — ``filterwarnings`` is idempotent for the
+    same rule.
+
+    Suppressed:
+
+    * ``RequestsDependencyWarning`` — ``requests`` emits this when the
+      installed ``urllib3`` / ``chardet`` / ``charset_normalizer`` versions
+      fall outside its supported range. The versions still work; the warning
+      is informational only.
+    * ``LangChainBetaWarning`` — ``soothe`` uses ``TypeSafeClassifier`` which
+      is a beta LangChain API. The API may change, but the warning is noise
+      for end users.
+    """
+    # ``requests`` import-time version-mismatch warning.
+    warnings.filterwarnings(
+        "ignore",
+        category=UserWarning,
+        message=r".*urllib3 .* or chardet .* doesn't match a supported version.*",
+    )
+    # Also match by the concrete warning class when available — covers the
+    # exact ``RequestsDependencyWarning`` emitted by ``requests/__init__.py``.
+    try:
+        from requests.exceptions import RequestsDependencyWarning
+
+        warnings.filterwarnings("ignore", category=RequestsDependencyWarning)
+    except Exception:  # pragma: no cover - requests not installed / API changed
+        pass
+
+    # ``soothe`` / LangChain beta-API warning from ``TypeSafeClassifier``.
+    try:
+        from langchain_core._api.beta_decorator import LangChainBetaWarning
+
+        warnings.filterwarnings("ignore", category=LangChainBetaWarning)
+    except Exception:  # pragma: no cover - langchain not installed / API changed
+        pass

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/core/backends/direct.py

@@ -55,5 +55,6 @@ class DirectRuntimeBackend:
             # The CLI resolves the interaction mode when it builds the agent
             # (auto / ask / bypass); nano must not be pinned back to "agent".
             interaction_mode=None,
+            resume_value=request.resume_value,
         ):
             yield event

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/core/bridges/nano/backend.py

@@ -57,6 +57,7 @@ class NanoRuntimeBackend:
             workspace=workspace,
             thread_id=session,
             interaction_mode=resolve_interaction_mode(request.metadata),
+            resume_value=request.resume_value,
         ):
             yield event
 

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/core/bridges/nano/mapping.py

@@ -298,6 +298,46 @@ def _wire_tool_call_update(
     return [ToolStarted(tool=name or "tool", call_id=tc_id, args=args or None)]
 
 
+def _extract_ask_user_interrupts(
+    raw: Any,
+) -> tuple[tuple[dict[str, Any], ...], tuple[str, ...]]:
+    """Pull ``ask_user`` questions and interrupt ids from a ``__interrupt__`` payload.
+
+    LangGraph emits ``__interrupt__`` as a tuple of ``Interrupt`` objects (or
+    dicts). Each carries a ``value`` with the interrupt payload; soothe's
+    ``ask_user`` tool tags it with ``{"type": "ask_user", "questions": [...]}``.
+
+    Returns ``(questions, interrupt_ids)`` — only questions from ``ask_user``
+    interrupts are surfaced; other interrupt kinds (tool approval, etc.) yield
+    an empty questions tuple but still carry their interrupt id so the CLI can
+    render a generic "paused for input" message.
+    """
+    if not isinstance(raw, (list, tuple)):
+        raw = (raw,) if raw is not None else ()
+    questions: list[dict[str, Any]] = []
+    interrupt_ids: list[str] = []
+    for entry in raw:
+        value: Any = None
+        int_id: str = ""
+        # LangGraph Interrupt objects have ``.value`` / ``.id``; serialized
+        # dicts use the same keys.
+        if hasattr(entry, "value"):
+            value = getattr(entry, "value", None)
+            int_id = str(getattr(entry, "id", "") or "")
+        elif isinstance(entry, dict):
+            value = entry.get("value")
+            int_id = str(entry.get("id", "") or "")
+        if int_id:
+            interrupt_ids.append(int_id)
+        if isinstance(value, dict) and value.get("type") == "ask_user":
+            qs = value.get("questions")
+            if isinstance(qs, list):
+                for q in qs:
+                    if isinstance(q, dict):
+                        questions.append(q)
+    return tuple(questions), tuple(interrupt_ids)
+
+
 async def iter_nano_runtime_events(
     agent: Any,
     *,
@@ -308,8 +348,14 @@ async def iter_nano_runtime_events(
     workspace: str | None = None,
     thread_id: str | None = None,
     interaction_mode: str | None = "agent",
+    resume_value: Any = None,
 ) -> AsyncIterator[RuntimeEvent]:
-    """Drive ``agent.astream`` and yield sanitized runtime events."""
+    """Drive ``agent.astream`` and yield sanitized runtime events.
+
+    When ``resume_value`` is set, the run resumes a paused graph (an
+    ``ask_user`` interrupt) with that value via ``Command(resume=...)``
+    instead of starting a new turn from ``input_text``.
+    """
     try:
         from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
     except ImportError as exc:  # pragma: no cover
@@ -327,7 +373,15 @@ async def iter_nano_runtime_events(
     if workspace:
         configurable["workspace"] = workspace
 
-    messages = [HumanMessage(content=input_text)]
+    # Resume a paused graph (ask_user interrupt) rather than starting a new
+    # turn. LangGraph's ``Command(resume=...)`` delivers the value to the
+    # ``interrupt()`` call that suspended the graph.
+    if resume_value is not None:
+        from langgraph.types import Command
+
+        payload: Any = Command(resume=resume_value)
+    else:
+        payload = {"messages": [HumanMessage(content=input_text)]}
     config = {"configurable": configurable}
     answer = ""
     composing = False
@@ -340,7 +394,7 @@ async def iter_nano_runtime_events(
 
     try:
         async for chunk in agent.astream(
-            {"messages": messages},
+            payload,
             config=config,
             stream_mode=["messages", "updates", "custom"],
             subgraphs=True,
@@ -369,7 +423,12 @@ async def iter_nano_runtime_events(
 
             if mode == "updates" and isinstance(data, dict):
                 if "__interrupt__" in data:
-                    yield InterruptWaiting(message="Waiting for input…")
+                    questions, interrupt_ids = _extract_ask_user_interrupts(data["__interrupt__"])
+                    yield InterruptWaiting(
+                        message="Waiting for input…",
+                        questions=questions,
+                        interrupt_ids=interrupt_ids,
+                    )
                     continue
                 # Plan steps (todos) and host middleware phases are the only
                 # signal soothe gives us about *what* it is doing between tool

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/core/events.py

@@ -63,7 +63,16 @@ class OutputTextDelta:
 
 @dataclass(frozen=True, slots=True)
 class InterruptWaiting:
+    """Agent paused for human input (``ask_user`` interrupt).
+
+    When the pause comes from soothe's ``ask_user`` tool, ``questions`` carries
+    the structured question specs the model asked, so the CLI can render them
+    and accept an answer that resumes the run on a follow-up invocation.
+    """
+
     message: str | None = None
+    questions: tuple[dict[str, Any], ...] = ()
+    interrupt_ids: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True, slots=True)
@@ -92,6 +101,10 @@ class RunRequest:
     session: str | None = None
     metadata: dict[str, Any] | None = None
     run_id: str | None = None
+    # When set, the run resumes a paused graph (``ask_user`` interrupt) with the
+    # given value instead of starting a new turn from ``input_text``. The value
+    # is passed to LangGraph's ``Command(resume=...)``.
+    resume_value: Any = None
 
 
 @dataclass(frozen=True, slots=True)

{flowjet-2.0.7 → flowjet-2.0.9}/src/flowjet/server/__main__.py

@@ -35,6 +35,12 @@ def _create_dual_stack_socket(host: str, port: int) -> socket.socket:
 
 
 def main() -> None:
+    # Silence noisy third-party warnings (requests version-mismatch,
+    # LangChain beta-API) before the agent stack is imported.
+    from flowjet.core._warnings import suppress_known_warnings
+
+    suppress_known_warnings()
+
     # Pull in a ~/.soothe/config copy before the first agent build. Kept out of
     # create_app(): the ASGI app is built at import time, and importing a module
     # must not write files.