flowjet 2.0.4__tar.gz → 2.0.6__tar.gz

{flowjet-2.0.4 → flowjet-2.0.6}/CHANGELOG.md

@@ -10,12 +10,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [2.0.4] — 2026-09-19
+## [2.0.6] — 2026-09-21
+
+### Changed
+
+- **Bump soothe runtime to the latest.** `soothe` `1.0.12 → 1.0.14` and
+  `soothe-nano` `1.2.28 → 1.3.0`. The `<1.3.0` cap on `soothe-nano` was lifted
+  to `<1.4.0` because `soothe 1.0.14` now requires `soothe-nano>=1.3.0`. The
+  upgrade adds one transitive dependency, `langchain-typesafe`. All FlowJet
+  import paths into soothe/soothe-nano (`SootheConfig`, `create_nano_agent`,
+  `create_dual_mode_nano_agent`, `create_soothe_agent`, `resolve_checkpointer`,
+  `register_builtin_skill_root`, `FrameworkFilesystem`, `diagnose`, etc.) are
+  unchanged and continue to resolve.
+
+## [2.0.5] — 2026-09-20
 
 ### Changed
 
-- Bumped `soothe` lower bound to `1.0.13` (was `1.0.12`). soothe-nano stays
-  pinned at `>=1.2.28,<1.3.0`.
+- **Config moved off `~/.soothe` — `FLOWJET_HOME` is now the authority.**
+  The config file resolves to `$FLOWJET_HOME/config/nano.yml` (default
+  `~/.flowjet/config/nano.yml`) instead of `$SOOTHE_HOME/config/nano.yml`, so an
+  exported `SOOTHE_HOME` can no longer drag flowjet back onto `~/.soothe`.
+  `SOOTHE_HOME` itself is left untouched: CLI data (thread pins, locks,
+  completion history), logs, agents, plugins and the sqlite databases still live
+  there. Upgrades keep working — an existing `~/.soothe/config/nano.yml` (plus a
+  sibling `soothe.yml`) is copied into `$FLOWJET_HOME/config/` **once**, on first
+  run, and the originals are left in place, so the move is reversible.
+- **`fj setup` no longer aborts when the LLM endpoint is unreachable.** A failed
+  or empty `/models` probe (connection refused, HTTP error, unresolved
+  `${ENV_VAR}`) now prints a `warning:` and falls through to manual model entry
+  — offering the models already saved for the selected provider, or accepting a
+  typed model id. The provider and router profile are still written, so a config
+  can be initialised before the model server is running; the run ends with a note
+  to re-check via `fj doctor`.
+
+## [2.0.4] — 2026-09-19
+
+### Fixed
+
+- **`fj -V` is instant (1.78s → 0.06s).** It paid the full `soothe_nano` +
+  `flowjet.core.bootstrap` import cost on every invocation just to print a
+  version string. The stdlib-only logging helpers moved out of `agent.py` into
+  `cli.py`, `main()` parses args before setting up logging so `-V`/`-h` exit
+  first, and the `-c/--config` help text now resolves lazily.
+  (`agent.py` keeps thin delegation wrappers, so existing imports and
+  monkeypatching are unaffected.)
 
 ## [2.0.3] — 2026-09-18
 

{flowjet-2.0.4 → flowjet-2.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowjet
-Version: 2.0.4
+Version: 2.0.6
 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
@@ -22,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.11
-Requires-Dist: soothe-nano<1.3.0,>=1.2.28
-Requires-Dist: soothe<2.0.0,>=1.0.13
+Requires-Dist: soothe-nano<1.4.0,>=1.3.0
+Requires-Dist: soothe<2.0.0,>=1.0.14
 Provides-Extra: dev
 Requires-Dist: httpx>=0.27.0; extra == 'dev'
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
@@ -75,7 +75,7 @@ export OPENAI_API_KEY=sk-...
 fj summarize README.md
 ```
 
-`fj setup` writes `~/.soothe/config/nano.yml`. Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
+`fj setup` writes `$FLOWJET_HOME/config/nano.yml` (default `~/.flowjet/config/nano.yml`). Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
 
 Not sure your machine is ready? `fj doctor` (add `--deep`, `--live-llm`).
 

{flowjet-2.0.4 → flowjet-2.0.6}/README.md

@@ -31,7 +31,7 @@ export OPENAI_API_KEY=sk-...
 fj summarize README.md
 ```
 
-`fj setup` writes `~/.soothe/config/nano.yml`. Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
+`fj setup` writes `$FLOWJET_HOME/config/nano.yml` (default `~/.flowjet/config/nano.yml`). Without it, FlowJet falls back to `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`.
 
 Not sure your machine is ready? `fj doctor` (add `--deep`, `--live-llm`).
 

{flowjet-2.0.4 → flowjet-2.0.6}/docs/impl/IG-002-isolated-thread-pool-runtime.md

@@ -193,8 +193,8 @@ graph; abnormal turns recycle it before the worker is made available.
 
 | Env | Settings field | Default |
 |-----|----------------|---------|
-| `FLOWJET_HOME` | `home` | `~/.flowjet` |
-| `FLOWJET_NANO_CONFIG` | `nano_config` | unset → `$SOOTHE_HOME/config/nano.yml` |
+| `FLOWJET_HOME` | `home` | `~/.flowjet` (config file + workspaces) |
+| `FLOWJET_NANO_CONFIG` | `nano_config` | unset → `$FLOWJET_HOME/config/nano.yml` |
 | `FLOWJET_THREAD_POOL_MIN` | `thread_pool_min` | `2` |
 | `FLOWJET_THREAD_POOL_MAX` | `thread_pool_max` | `8` |
 | `FLOWJET_THREAD_POOL_IDLE_TIMEOUT` | `thread_pool_idle_timeout` | `300` |

{flowjet-2.0.4 → flowjet-2.0.6}/docs/server.md

@@ -72,8 +72,8 @@ with client.responses.stream(
 | `FLOWJET_MODELS` | `default` | Comma-separated logical model ids |
 | `FLOWJET_HOST` | `::` | Bind host (dual-stack IPv4/IPv6) |
 | `FLOWJET_PORT` | `8618` | Bind port |
-| `FLOWJET_HOME` | `~/.flowjet` | Root for per-session workspaces |
-| `FLOWJET_NANO_CONFIG` | unset | Optional `nano.yml` (else `$SOOTHE_HOME/config/nano.yml`) |
+| `FLOWJET_HOME` | `~/.flowjet` | Root for the config file (`$FLOWJET_HOME/config/nano.yml`) and per-session workspaces |
+| `FLOWJET_NANO_CONFIG` | unset | Optional `nano.yml` (else `$FLOWJET_HOME/config/nano.yml`) |
 | `FLOWJET_THREAD_POOL_MIN` | `2` | Min isolation worker threads |
 | `FLOWJET_THREAD_POOL_MAX` | `8` | Max isolation worker threads |
 | `FLOWJET_THREAD_POOL_IDLE_TIMEOUT` | `300` | Scaled-worker idle exit seconds (`0` = never) |

{flowjet-2.0.4 → flowjet-2.0.6}/examples/README.md

@@ -35,7 +35,8 @@ make examples-e2e
 ```
 
 The server uses soothe-nano with thread-pool isolation. Nano loads
-`~/.soothe/config/nano.yml` (or `FLOWJET_NANO_CONFIG`) and its active router profile.
+`$FLOWJET_HOME/config/nano.yml` (default `~/.flowjet/config/nano.yml`, or
+`FLOWJET_NANO_CONFIG`) and its active router profile.
 
 ## Environment
 

{flowjet-2.0.4 → flowjet-2.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flowjet"
-version = "2.0.4"
+version = "2.0.6"
 description = "FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano"
 readme = "README.md"
 license = { text = "MIT" }
@@ -31,8 +31,8 @@ classifiers = [
 dependencies = [
     # Default CLI runtime (FLOWJET_BACKEND=soothe). soothe is a host layer over
     # soothe-nano, so nano stays pinned explicitly: soothe only caps it at <2.
-    "soothe>=1.0.13,<2.0.0",
-    "soothe-nano>=1.2.28,<1.3.0",
+    "soothe>=1.0.14,<2.0.0",
+    "soothe-nano>=1.3.0,<1.4.0",
 ]
 
 [project.optional-dependencies]

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/cli/cli.py

@@ -44,20 +44,14 @@ class _CompactConsoleFormatter(logging.Formatter):
         return super().format(record)
 
 
-_FILE_LOGGING_INSTALLED = False
-
-
 def configure_cli_logging(*, verbose: bool = False) -> None:
-    """Quiet the console for one-shot CLI use and enable file logging by default.
+    """Quiet the console for one-shot CLI use.
 
     - Opt out of ``browser_use`` import-time root logger setup when unset.
     - Remove existing root stream handlers (stderr/stdout) so init INFO
       lines do not interleave with the agent answer.
     - Prevent ``lastResort`` traceback dumps from soothe tool failures.
     - When ``verbose``, show WARNING+ as single-line messages on stderr.
-    - Attach a rotating file handler at ``<FLOWJET_HOME>/logs/cli.log`` so
-      every CLI run is recorded by default (idempotent across re-invocations
-      within the same process, e.g. tests).
     """
     os.environ.setdefault(_BROWSER_USE_SETUP_LOGGING, "false")
     _remove_root_console_handlers()
@@ -75,25 +69,6 @@ def configure_cli_logging(*, verbose: bool = False) -> None:
     if root.level < logging.WARNING:
         root.setLevel(logging.WARNING)
 
-    _ensure_cli_file_logging()
-
-
-def _ensure_cli_file_logging() -> None:
-    """Attach the rotating file handler for CLI runs (idempotent)."""
-    global _FILE_LOGGING_INSTALLED
-    if _FILE_LOGGING_INSTALLED:
-        return
-    try:
-        from flowjet.core.home import cli_log_path, ensure_flowjet_home
-
-        ensure_flowjet_home()
-        from soothe_nano.logging.setup import setup_logging
-
-        setup_logging(log_file=str(cli_log_path()), extra_logger_names=("flowjet",))
-        _FILE_LOGGING_INSTALLED = True
-    except Exception:  # pragma: no cover - logging must never break the CLI
-        pass
-
 
 def silence_after_plugins(*, verbose: bool = False) -> None:
     """Re-apply quieting after plugin imports (belt-and-suspenders)."""
@@ -321,7 +296,7 @@ class _HelpFormatter(argparse.RawDescriptionHelpFormatter):
 
 
 def _default_config_help() -> str:
-    from flowjet.cli.agent import default_config_path
+    from flowjet.home import default_config_path
 
     return f"Alternate nano.yml (default: {default_config_path()})"
 
@@ -687,12 +662,6 @@ def main_follow(argv: list[str] | None = None) -> int:
 
 def main(argv: list[str] | None = None) -> int:
     try:
-        # Align SOOTHE_HOME with FLOWJET_HOME before any soothe import so
-        # config, data, and logs all land under ~/.flowjet. Must run first:
-        # soothe_sdk.paths binds SOOTHE_HOME at import time.
-        from flowjet.core.home import ensure_flowjet_home
-
-        ensure_flowjet_home()
         # Parse first so ``-V`` / ``-h`` / ``--help`` exit before we touch the
         # logging stack (and the heavy ``flowjet.cli.agent`` import it used to
         # drag in). Version/help must stay instant.

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/cli/completion/engine.py

@@ -419,13 +419,14 @@ def _split_complete_argv(raw: list[str]) -> tuple[list[str], list[str]]:
 def run_complete(argv: list[str] | None = None) -> int:
     """Hidden shell protocol: print one candidate per stdout line."""
     from flowjet.cli.cli import resolve_cli_prog
+    from flowjet.home import default_config_path
 
     parser = argparse.ArgumentParser(prog=f"{resolve_cli_prog()} __complete", add_help=True)
     parser.add_argument(
         "-c",
         "--config",
         metavar="PATH",
-        help="nano.yml path (default: ~/.soothe/config/nano.yml)",
+        help=f"nano.yml path (default: {default_config_path()})",
     )
     parser.add_argument(
         "--no-llm",

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/cli/doctor_cmd.py

@@ -46,8 +46,8 @@ REFERENCE_SKILLS: tuple[dict[str, Any], ...] = (
 
 
 def _build_parser() -> argparse.ArgumentParser:
-    from flowjet.cli.agent import default_config_path
     from flowjet.cli.cli import resolve_cli_prog
+    from flowjet.home import default_config_path
 
     parser = argparse.ArgumentParser(
         prog=f"{resolve_cli_prog()} doctor",

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/cli/setup_cmd.py

@@ -21,7 +21,7 @@ except ImportError:  # pragma: no cover - Windows
 import yaml
 from soothe_nano.config import _ENV_VAR_RE, _resolve_env
 
-from flowjet.cli.agent import default_config_path
+from flowjet.home import default_config_path, ensure_flowjet_config
 
 DEFAULT_PROVIDER_NAME = "local"
 DEFAULT_NEW_PROVIDER_NAME = "flowjet-default"
@@ -65,6 +65,10 @@ def run_setup(config_path: str | None = None) -> int:
 
 def _run_setup(config_path: str | None = None) -> int:
     path = Path(config_path).expanduser() if config_path else default_config_path()
+    if config_path is None:
+        # ``fj setup`` bypasses ``load_config``, so it pulls in a ``~/.soothe/config``
+        # copy itself before reading the provider list.
+        ensure_flowjet_config()
     existing = _load_existing_config(path)
     providers = _list_providers(existing)
     _, seed_model = _seed_from_config(existing)
@@ -100,27 +104,39 @@ def _run_setup(config_path: str | None = None) -> int:
     api_key = _prompt_secret_with_default("API key", api_key_default)
 
     sys.stdout.write("Fetching available models...\n")
+    models: list[str] = []
+    fetch_issue: str | None = None
     try:
         resolved_endpoint = resolve_config_value(endpoint, field="API endpoint")
         resolved_api_key = resolve_config_value(api_key, field="API key")
-        models = fetch_models(resolved_endpoint, resolved_api_key)
     except RuntimeError as exc:
-        sys.stderr.write(f"error: {exc}\n")
-        return 1
-
-    if not models:
-        sys.stderr.write("error: no models returned by endpoint\n")
-        return 1
-
-    preferred = seed_model
-    if selected:
-        selected_models = selected.get("models")
-        if isinstance(selected_models, list) and selected_models:
-            preferred = str(selected_models[0])
-    if preferred and preferred in models:
-        models = [preferred] + [m for m in models if m != preferred]
+        fetch_issue = str(exc)
+    else:
+        try:
+            models = fetch_models(resolved_endpoint, resolved_api_key)
+        except RuntimeError as exc:
+            fetch_issue = str(exc)
+        if not models and fetch_issue is None:
+            fetch_issue = f"{resolved_endpoint} returned no models"
+
+    if fetch_issue:
+        # An unreachable endpoint is not fatal: save the provider anyway so the
+        # user can start the model server later and pick a model by hand now.
+        sys.stderr.write(f"warning: could not list models ({fetch_issue})\n")
+        sys.stderr.write("warning: continuing without a model list\n")
+
+    if models:
+        preferred = seed_model
+        if selected:
+            selected_models = selected.get("models")
+            if isinstance(selected_models, list) and selected_models:
+                preferred = str(selected_models[0])
+        if preferred and preferred in models:
+            models = [preferred] + [m for m in models if m != preferred]
+        model = choose_model_interactive(models)
+    else:
+        model = _prompt_model_with_fallback(_fallback_model_candidates(selected, seed_model))
 
-    model = choose_model_interactive(models)
     if not model:
         sys.stderr.write("setup cancelled\n")
         return 1
@@ -139,6 +155,10 @@ def _run_setup(config_path: str | None = None) -> int:
     sys.stdout.write(f"Saved config to: {path}\n")
     sys.stdout.write(f"Active profile: {profile}\n")
     sys.stdout.write(f"Configured model: {provider_name}:{model}\n")
+    if fetch_issue:
+        sys.stdout.write(
+            "Note: model list was not verified; start the endpoint and run 'fj doctor' to confirm.\n"
+        )
     return 0
 
 
@@ -464,6 +484,45 @@ def _parse_model_filter(choice: str) -> str:
     return raw
 
 
+def _fallback_model_candidates(selected: dict[str, Any], seed_model: str | None) -> list[str]:
+    """Models already known from config, used when the endpoint cannot be queried."""
+    candidates: list[str] = []
+    if selected:
+        models = selected.get("models")
+        if isinstance(models, list):
+            candidates.extend(str(item) for item in models if str(item).strip())
+    if seed_model and seed_model not in candidates:
+        candidates.insert(0, seed_model)
+    return candidates
+
+
+def _prompt_model_with_fallback(candidates: list[str]) -> str | None:
+    """Ask for a model id directly when the endpoint has no model list to pick from."""
+    default = candidates[0] if candidates else DEFAULT_MODEL
+    if candidates:
+        sys.stdout.write("Models saved for this provider:\n")
+        for idx, name in enumerate(candidates, start=1):
+            sys.stdout.write(f"  {idx}. {name}\n")
+        label = f"Model name or number 1-{len(candidates)}"
+    else:
+        label = "Model name"
+
+    while True:
+        try:
+            value = input(f"{label} [{default}]: ").strip()
+        except EOFError:
+            return default
+        if not value:
+            return default
+        if value.isdigit() and candidates:
+            idx = int(value)
+            if 1 <= idx <= len(candidates):
+                return candidates[idx - 1]
+            sys.stdout.write(f"Invalid number; enter 1-{len(candidates)} or a model name.\n")
+            continue
+        return value
+
+
 def _load_existing_config(path: Path) -> dict[str, Any]:
     if not path.is_file():
         return {}

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/core/bootstrap.py

@@ -18,7 +18,7 @@ from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any
 
-from soothe_nano.config import SOOTHE_HOME, SootheConfig
+from soothe_nano.config import SootheConfig
 from soothe_nano.resolve import resolve_checkpointer
 
 from flowjet.core.backend import Backend, resolve_backend
@@ -29,6 +29,8 @@ from flowjet.core.modes import (
     SurfaceProfile,
     require_mode,
 )
+from flowjet.home import default_config_path as _flowjet_config_path
+from flowjet.home import ensure_flowjet_config
 
 logger = logging.getLogger(__name__)
 
@@ -75,8 +77,8 @@ def register_flowjet_builtin_skills() -> None:
 
 
 def default_config_path() -> Path:
-    """Return ``~/.soothe/config/nano.yml`` (respects ``SOOTHE_HOME``)."""
-    return SOOTHE_HOME / "config" / "nano.yml"
+    """Return ``$FLOWJET_HOME/config/nano.yml`` (default ``~/.flowjet/config/nano.yml``)."""
+    return _flowjet_config_path()
 
 
 def load_config(
@@ -93,14 +95,21 @@ def load_config(
 
     Resolution order:
     1. Explicit ``config_path``
-    2. ``SOOTHE_HOME / config / nano.yml`` (default ``~/.soothe/config/nano.yml``)
+    2. ``$FLOWJET_HOME / config / nano.yml`` (default ``~/.flowjet/config/nano.yml``)
     3. Zero-config ``SootheConfig()`` from ``OPENAI_API_KEY`` / ``ANTHROPIC_API_KEY``
 
     On the ``soothe`` backend, a sibling ``soothe.yml`` (host-owned keys) is
     composed over ``nano.yml`` when present.
+
+    Without an explicit ``config_path``, a config found in ``~/.soothe/config`` is
+    copied into the flowjet home first — see :func:`flowjet.home.ensure_flowjet_config`.
     """
     backend = backend or resolve_backend(Surface.CLI)
-    path = Path(config_path).expanduser() if config_path else default_config_path()
+    if config_path is None:
+        ensure_flowjet_config()
+        path = default_config_path()
+    else:
+        path = Path(config_path).expanduser()
     if path.is_file():
         return _load_config_file(path, backend)
     if config_path is not None:

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/core/bridges/nano/mapping.py

@@ -33,6 +33,13 @@ _SKIP_CUSTOM_TYPES = frozenset(
     }
 )
 
+# Host (soothe) executor emits this as a ``mode=custom`` chunk carrying
+# pre-parsed tool kwargs — a structured wire event that bypasses the fragile
+# ``tool_call_chunks`` partial-JSON accumulation. Handled in
+# ``iter_nano_runtime_events`` (not ``map_custom``) so it can yield a real
+# ``ToolStarted`` and feed the accumulator's arg overlays.
+_STREAM_TOOL_CALL_UPDATE = "soothe.stream.tool_call.update"
+
 # Host (soothe) middleware surfaces as ``<Middleware>.<phase>`` graph updates.
 # The CLI renders these through ``friendly_progress``, so the synthetic payloads
 # below stay in the same ``soothe.*`` vocabulary as nano's custom events.
@@ -216,6 +223,10 @@ def map_custom(data: dict[str, Any]) -> Progress | None:
     event_type = str(data.get("type") or "").strip()
     if not event_type or event_type in _SKIP_CUSTOM_TYPES:
         return None
+    if event_type == _STREAM_TOOL_CALL_UPDATE:
+        # Handled in ``iter_nano_runtime_events`` — yields a ToolStarted /
+        # Progress refresh with the pre-parsed args, never a generic Progress.
+        return None
     if event_type.startswith("soothe.output."):
         return None
     short = event_type[7:] if event_type.startswith("soothe.") else event_type
@@ -232,6 +243,61 @@ def map_custom(data: dict[str, Any]) -> Progress | None:
     return Progress(stage=str(stage), message=str(message or "Working"), raw=data)
 
 
+def _wire_tool_call_update(
+    data: dict[str, Any],
+    *,
+    emitted_calls: set[str],
+    refreshed_calls: set[str],
+    tool_args: ToolCallArgAccumulator,
+) -> list[RuntimeEvent]:
+    """Convert a ``soothe.stream.tool_call.update`` into ToolStarted / Progress.
+
+    The host (soothe) executor pre-parses tool kwargs and emits them as a
+    structured wire event — an efficient transit path that does not depend on
+    ``tool_call_chunks`` partial-JSON accumulation. This makes that path
+    first-class: a new call id yields ``ToolStarted`` (same as the
+    ``messages`` path), and a repeat yields a ``Progress`` refresh so the
+    status line picks up the parsed args.
+
+    Args are also fed into ``tool_args`` overlays so the eventual
+    ``ToolCompleted`` event carries them even if the ``messages``-mode chunks
+    never produced parseable JSON.
+    """
+    tc_id = str(data.get("tool_call_id") or "").strip()
+    name = str(data.get("name") or "").strip()
+    args = data.get("args")
+    if not isinstance(args, dict):
+        args = {}
+    if not tc_id:
+        return []
+    # Seed the accumulator's overlay so ToolCompleted (messages path) sees
+    # the parsed args even if tool_call_chunks were empty or partial.
+    tool_args.seed_overlay(tc_id, name=name, args=args)
+    # Quiet tools (write_todos) are plan bookkeeping that already surfaces as
+    # step progress — never emit a ToolStarted for them.
+    if name in _QUIET_TOOLS:
+        return []
+    if tc_id in emitted_calls:
+        # Already started via the messages path; refresh the status line with
+        # the parsed args (Writing a.txt, not bare Writing).
+        if args and tc_id not in refreshed_calls:
+            refreshed_calls.add(tc_id)
+            return [
+                Progress(
+                    stage="Tool",
+                    message=tool_call_summary(name or "tool", args),
+                    raw={
+                        "type": "soothe.tool.started",
+                        "tool": name,
+                        "args": args,
+                    },
+                )
+            ]
+        return []
+    emitted_calls.add(tc_id)
+    return [ToolStarted(tool=name or "tool", call_id=tc_id, args=args or None)]
+
+
 async def iter_nano_runtime_events(
     agent: Any,
     *,
@@ -284,6 +350,18 @@ async def iter_nano_runtime_events(
             _ns, mode, data = chunk
 
             if mode == "custom" and isinstance(data, dict):
+                # Host (soothe) wire tool-call update: pre-parsed args that
+                # bypass tool_call_chunks partial-JSON accumulation. Handle
+                # before map_custom so it yields a real ToolStarted.
+                if str(data.get("type") or "").strip() == _STREAM_TOOL_CALL_UPDATE:
+                    for event in _wire_tool_call_update(
+                        data,
+                        emitted_calls=emitted_calls,
+                        refreshed_calls=refreshed_calls,
+                        tool_args=tool_args,
+                    ):
+                        yield event
+                    continue
                 mapped = map_custom(data)
                 if mapped:
                     yield mapped

{flowjet-2.0.4 → flowjet-2.0.6}/src/flowjet/core/tool_stream.py

@@ -244,3 +244,32 @@ class ToolCallArgAccumulator:
         name = str(state.get("name") or "") or None
         args = _merge_args(parse_partial_args(str(state.get("args_str") or "")), overlay)
         return name, args
+
+    def seed_overlay(
+        self,
+        tool_call_id: str,
+        *,
+        name: str = "",
+        args: dict[str, Any] | None = None,
+    ) -> None:
+        """Seed name + parsed args for a call from a wire (non-chunk) source.
+
+        The host (soothe) executor emits ``soothe.stream.tool_call.update``
+        custom events with pre-parsed kwargs. Feeding them here lets
+        ``ToolCompleted`` (messages path) resolve the name and args even when
+        ``tool_call_chunks`` streamed empty/partial JSON — the overlay is the
+        fallback in ``_resolved_args`` / ``pop``.
+        """
+        tc_id = str(tool_call_id or "").strip()
+        if not tc_id:
+            return
+        if name:
+            state = self._ensure(tc_id)
+            if not state.get("name"):
+                state["name"] = name
+            self._last_active_id = tc_id
+        if isinstance(args, dict) and args:
+            prev = self._overlays.get(tc_id) or {}
+            merged = _merge_args(prev, args)
+            if merged != prev:
+                self._overlays[tc_id] = merged