dulus 3.14.18__tar.gz → 3.15.0__tar.gz

{dulus-3.14.18/dulus.egg-info → dulus-3.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.14.18
+Version: 3.15.0
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author-email: KevRojo <dev@dulus.ai>
 Maintainer-email: KevRojo <dev@dulus.ai>
@@ -464,6 +464,8 @@ Those numbers are not a vanity dashboard. They explain the product: Dulus is bui
 
 ## Install in 30 seconds
 
+> **Dulus runs on a free Dulus account.** The first `dulus` opens your browser to sign in; after that the session is remembered. CI, scripts and servers: set `DULUS_API_KEY` to a `dulus_sk_*` key from `/login dulus key`. `--version` and `--help` never ask.
+
 If Python 3.11 or newer is already installed:
 
 ```bash

{dulus-3.14.18 → dulus-3.15.0}/README.md

@@ -359,6 +359,8 @@ Those numbers are not a vanity dashboard. They explain the product: Dulus is bui
 
 ## Install in 30 seconds
 
+> **Dulus runs on a free Dulus account.** The first `dulus` opens your browser to sign in; after that the session is remembered. CI, scripts and servers: set `DULUS_API_KEY` to a `dulus_sk_*` key from `/login dulus key`. `--version` and `--help` never ask.
+
 If Python 3.11 or newer is already installed:
 
 ```bash

{dulus-3.14.18 → dulus-3.15.0}/docs/CHANGELOG.md

@@ -88,7 +88,7 @@ set a provider key, or `/model ollama/<name>` to pick a supported route.
 - **First-turn amnesia**: agent + lookback strip GUI/REPL gold/soul/welcome *display* blobs before the provider call, so web-history consolidate no longer treats gold as “last assistant reply” and drops real context
 - **MemPalace dual-path noise**: per-turn inject (CLI + WebChat) skips `short_memory` / soul — already in the system prompt
 - **Second `/compact` archive wipe**: `save_loopback_archive` refuses to shrink; Loopback keeps the full pre-compact history across N compacts
-- **WebChat gold preload**: session seeds gold *display* copies for the transcript; model source of truth is still the system prompt (public GUI stays as-is — this is server/engine, not an Interant GUI port)
+- **WebChat gold preload**: session seeds gold *display* copies for the transcript; model source of truth is still the system prompt (public GUI stays as-is — this is server/engine, not a port of the private GUI)
 
 ### Tests
 - `test_gold_memory_preload` + `test_lookback_compact` (11 passed)

{dulus-3.14.18 → dulus-3.15.0}/docs/news.md

@@ -2,7 +2,11 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
-- November 3, 2026 (**📡 v3.14.18 — Dulus Radio gets a station ident**): **The first screen you see now says who is talking.** Dulus Radio — the dispatch board that prints on every interactive boot — gained a station ident: *Interant · Santo Domingo 🇩🇴 · what shipped while you were away*, so a fresh install learns who builds this and what the board is for instead of reading a bare "ON AIR". The sign-off states the honest bit too: **this repo is a mirror, and the signed desktop build runs ahead of it.** **Long dispatch headlines no longer wreck the layout** — a headline is capped at 68 characters and the overflow moves into the body, so the board stays readable on an 80-column terminal and no detail is lost; the cut prefers a sentence or clause boundary over splitting a word. The README also now documents the real distance between this mirror and the signed line: **2.2× the commits, 4.3× the code, 13.3× the 30-day velocity.** `pip install -U dulus`. 🦅🇩🇴
+- November 9, 2026 (**🔐 v3.15.0 — Dulus now runs on a Dulus account**): **Sign in once, then it's all yours.** From this release on, the first launch asks you to sign in with a free Dulus account — your browser opens, you approve, and you're back in the terminal. That's the whole ritual: the session is remembered and renewed quietly, and when Dulus can't be reached for a renewal you keep working offline. CI, scripts and servers skip the browser: set `DULUS_API_KEY` to a `dulus_sk_*` key minted with `/login dulus key`. `--version` and `--help` stay open to everyone, and your own provider keys (OpenAI, Anthropic, Ollama…) work exactly as before — they just ride on a signed-in Dulus now. `pip install -U dulus`. 🦅🇩🇴
+
+- November 3, 2026 (**📡 v3.14.19 — the boot ident signs with our own name**): **One small, public-facing fix.** The Dulus Radio station ident that prints on every interactive boot now signs with the product's own name. Same board, same dispatch, same sign-off about this repo being a mirror — only the signature changed. `pip install -U dulus`. 🦅🇩🇴
+
+- November 3, 2026 (**📡 v3.14.18 — Dulus Radio gets a station ident**): **The first screen you see now says who is talking.** Dulus Radio — the dispatch board that prints on every interactive boot — gained a station ident: *Dulus · Santo Domingo 🇩🇴 · what shipped while you were away*, so a fresh install learns who builds this and what the board is for instead of reading a bare "ON AIR". The sign-off states the honest bit too: **this repo is a mirror, and the signed desktop build runs ahead of it.** **Long dispatch headlines no longer wreck the layout** — a headline is capped at 68 characters and the overflow moves into the body, so the board stays readable on an 80-column terminal and no detail is lost; the cut prefers a sentence or clause boundary over splitting a word. The README also now documents the real distance between this mirror and the signed line: **2.2× the commits, 4.3× the code, 13.3× the 30-day velocity.** `pip install -U dulus`. 🦅🇩🇴
 
 - October 29, 2026 (**🧠 v6.4.1 — memory that stays with you**): **Memory belongs to the profile now.** Recall was missing things it had already saved; both sides of the memory path are scoped to the profile you are actually running, so what you save is what comes back. **Context limits finally add up** — the per-source budgets are one real ceiling instead of separate numbers that never summed. **Bash commands no longer cut themselves off mid-run**, so a long build returns its whole output instead of a truncated tail. **Native installers are back on both platforms**: a signed `.exe` for Windows and a `.dmg` for macOS ARM64, no Python setup required. A **silent nudge in the taskbar** tells you a reply is waiting instead of leaving you staring at a dead window. And **Dulus Business** — the deployable stack and the owners' dashboard — is back in the repo. Grab the signed build from [dulus-updates](https://github.com/Dulus-Ai/dulus-updates/releases/tag/v6.4.1), or `pip install -U dulus` for the open runtime. 🦅🇩🇴
 

{dulus-3.14.18 → dulus-3.15.0/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.14.18
+Version: 3.15.0
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author-email: KevRojo <dev@dulus.ai>
 Maintainer-email: KevRojo <dev@dulus.ai>
@@ -464,6 +464,8 @@ Those numbers are not a vanity dashboard. They explain the product: Dulus is bui
 
 ## Install in 30 seconds
 
+> **Dulus runs on a free Dulus account.** The first `dulus` opens your browser to sign in; after that the session is remembered. CI, scripts and servers: set `DULUS_API_KEY` to a `dulus_sk_*` key from `/login dulus key`. `--version` and `--help` never ask.
+
 If Python 3.11 or newer is already installed:
 
 ```bash

{dulus-3.14.18 → dulus-3.15.0}/dulus.egg-info/SOURCES.txt

@@ -288,6 +288,7 @@ tests/test_diff_view.py
 tests/test_diff_visualization.py
 tests/test_display_blocks.py
 tests/test_dulus_account.py
+tests/test_empty_assistant_turn.py
 tests/test_export_import.py
 tests/test_grok_usage.py
 tests/test_hook_engine.py
@@ -295,6 +296,7 @@ tests/test_injection_fix.py
 tests/test_interruptible_stream.py
 tests/test_json_protocol.py
 tests/test_license.py
+tests/test_login_gate.py
 tests/test_mcp.py
 tests/test_mcp_algolia.py
 tests/test_memory.py

{dulus-3.14.18 → dulus-3.15.0}/dulus.egg-info/top_level.txt

@@ -32,6 +32,7 @@ multi_agent
 paste_placeholders
 personality_config
 plugin
+plugins
 profiles
 providers
 pyconsole

{dulus-3.14.18 → dulus-3.15.0}/dulus.py

@@ -375,7 +375,7 @@ try:
     from importlib.metadata import version as _pkg_version
     VERSION = _pkg_version("dulus")
 except Exception:
-    VERSION = "3.14.18"  # dev fallback — keep in sync with pyproject.toml
+    VERSION = "3.15.0"  # dev fallback — keep in sync with pyproject.toml
 
 # ── Machine-readable protocol output (`--output json`) ─────────────────────
 # Dulus is increasingly run as a child process by another agent runtime (an
@@ -9042,7 +9042,7 @@ def _print_news_broadcast(
     # Station ident. This is the first thing a new install ever reads, so it
     # says who is broadcasting and what the board is actually for.
     print(
-        clr("    Interant", "white", "bold")
+        clr("    Dulus", "white", "bold")
         + clr("  ·  Santo Domingo 🇩🇴  ·  ", "dim")
         + clr("what shipped while you were away", "cyan", "dim")
     )
@@ -11241,7 +11241,7 @@ def repl(config: dict, initial_prompt: str | None = None):
             "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠛⠻⢾⣯⣧⣬⣭⣤⡶⠖⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
         ]
         _DULUS_LOGO.append("     " + clr("v" + VERSION, "green", "bold"))
-        _DULUS_LOGO.append("     " + clr("📡 Dulus Radio  ·  by Interant  ·  ON AIR at boot", "cyan", "dim"))
+        _DULUS_LOGO.append("     " + clr("📡 Dulus Radio  ·  ON AIR at boot", "cyan", "dim"))
         _DULUS_LOGO.append("                                                                 ")
 
         # Shared Dulus animation language for the short boot beat. Redirected
@@ -13075,6 +13075,110 @@ def repl(config: dict, initial_prompt: str | None = None):
 
 # ── Entry point ────────────────────────────────────────────────────────────
 
+def _attached_to_msys_pty(stream) -> bool:
+    """Is this stream a mintty terminal (Git Bash, MSYS2, Cygwin)?
+
+    mintty hands Windows programs a named pipe instead of a console, so
+    isatty() says nobody is there even with a person typing. The pipe's name
+    gives the terminal away, and ordinary pipes (`| tail`, a subprocess
+    capture) never carry it. MSYSTEM can't be trusted for this: every child
+    of such a shell inherits it, scripts and scheduled jobs included.
+    """
+    if sys.platform != "win32":
+        return False
+    try:
+        import ctypes
+        import msvcrt
+        from ctypes import wintypes
+
+        class _FileNameInfo(ctypes.Structure):
+            _fields_ = [("FileNameLength", wintypes.DWORD), ("FileName", wintypes.WCHAR * 260)]
+
+        info = _FileNameInfo()
+        handle = wintypes.HANDLE(msvcrt.get_osfhandle(stream.fileno()))
+        file_name_info = 2  # FILE_INFO_BY_HANDLE_CLASS.FileNameInfo
+        if not ctypes.windll.kernel32.GetFileInformationByHandleEx(
+                handle, file_name_info, ctypes.byref(info), ctypes.sizeof(info)):
+            return False
+        name = info.FileName[: info.FileNameLength // 2]
+    except Exception:
+        return False
+    return re.match(r"\\(cygwin|msys)-[0-9a-fA-F]+-pty\d+-(from|to)-master", name) is not None
+
+
+def _login_gate_can_prompt() -> bool:
+    """Is a person there to see a sign-in link? CI never counts."""
+    if os.environ.get("CI"):
+        return False
+    for stream in (sys.stdout, sys.stderr):
+        if stream is None:
+            continue
+        try:
+            if stream.isatty() or _attached_to_msys_pty(stream):
+                return True
+        except Exception:
+            pass
+    return False
+
+
+def _require_dulus_login(args) -> None:
+    """Dulus runs on a free Dulus account: no account, no Dulus.
+
+    Checked once per launch, after --version/--help (those stay open to
+    everyone). Background job runners are spawned by a session that already
+    passed here, and `dulus -c "login dulus"` / `-c logout` stay reachable so
+    a broken sign-in can always be fixed from the command line. Renewal only
+    happens when a person launched Dulus; background children and `-c` runs
+    take the stored session at its word so parallel launches never race to
+    rotate the same refresh token.
+    """
+    if args.run_tool or args.job_id or args.job_path:
+        return
+    if args.exec_cmd:
+        verb = " ".join(args.exec_cmd).strip().strip("\"'").lstrip("/").split(" ", 1)[0].lower()
+        if verb in ("login", "logout"):
+            return
+
+    import dulus_account
+
+    protocol = _protocol_enabled()
+    can_prompt = not protocol and _login_gate_can_prompt()
+    status = dulus_account.session_status(renew=can_prompt and not args.exec_cmd)
+    if status == "active":
+        return
+    if status == "offline":
+        print(clr("[dulus] Couldn't reach Dulus to renew your sign-in — carrying on offline.", "gray"),
+              file=sys.stderr)
+        return
+
+    if status == "invalid_key":
+        message = ("DULUS_API_KEY is set but isn't a Dulus key (those start with dulus_sk_). Replace "
+                   "it with one minted by `/login dulus key`, or unset it to use your sign-in.")
+    elif not can_prompt:
+        message = ("Dulus needs a free Dulus account. Sign in once with `dulus -c \"login dulus\"` "
+                   "(or just run `dulus` in a terminal). For CI, scripts and servers, set "
+                   "DULUS_API_KEY to a dulus_sk_* key minted with `/login dulus key`.")
+    else:
+        message = ""
+    if message:
+        if protocol:
+            _emit_error(message)
+        else:
+            print(f"[dulus] {message}", file=sys.stderr)
+        sys.exit(2)
+
+    print(clr("\n  Dulus runs on a free Dulus account — sign in once and you're in.\n", "cyan"))
+    try:
+        token = dulus_account.login(notify=lambda m: print(clr(m, "cyan")))
+    except KeyboardInterrupt:
+        token = None
+    if not token:
+        print(clr("[dulus] Sign-in didn't finish. Run `dulus` again whenever you're ready.", "yellow"),
+              file=sys.stderr)
+        sys.exit(1)
+    ok("Signed in — welcome aboard. 🦅")
+
+
 def main():
     parser = argparse.ArgumentParser(
         prog="dulus",
@@ -13139,6 +13243,9 @@ def main():
     from config import load_config, save_config, has_api_key
     from providers import detect_provider, PROVIDERS
 
+    # No account, no Dulus: sign in (or learn how) before anything else runs.
+    _require_dulus_login(args)
+
     # ── First-run welcome wizard ──────────────────────────────────────────
     # Runs BEFORE load_config() so we detect the absence of config.json.
     # The wizard mutates config in-place and persists it; subsequent

{dulus-3.14.18 → dulus-3.15.0}/dulus_account.py

@@ -43,6 +43,7 @@ _AUTH0_SCOPES = "openid profile email"
 # Refresh slightly early so a request never leaves with a token that expires
 # while it is in flight.
 _EXPIRY_BUFFER_SECONDS = 60
+API_KEY_PREFIX = "dulus_sk_"  # what `/login dulus key` mints
 
 
 def _is_text_browser(name: str) -> bool:
@@ -157,12 +158,13 @@ def _persist_tokens(payload: dict) -> dict:
     return store
 
 
-def refresh(refresh_token: str) -> dict | None:
-    """Exchange a refresh token for a fresh access token.
+def _renew(refresh_token: str, timeout: float = 30) -> tuple[str, dict | None]:
+    """One refresh round-trip against ``/v1/oauth/token``.
 
-    The server rotates refresh tokens, so the response carries a new one that
-    replaces the old. A failure here means the token was revoked or replayed
-    and the user has to sign in again.
+    Returns ``("ok", store)`` once the new tokens are saved, ``("refused", None)``
+    when Dulus said no (revoked, expired for good, account gone) and
+    ``("unreachable", None)`` when it could not answer — no network, a timeout,
+    or a 5xx/429 on our side.
     """
     import requests
 
@@ -174,13 +176,37 @@ def refresh(refresh_token: str) -> dict | None:
                 "client_id": DULUS_OAUTH_CLIENT_ID,
                 "refresh_token": refresh_token,
             },
-            timeout=30,
+            timeout=timeout,
         )
-        if response.status_code != 200:
-            return None
-        return _persist_tokens(response.json())
     except Exception:
-        return None
+        return "unreachable", None
+    if response.status_code in (400, 401, 403):
+        return "refused", None
+    if response.status_code != 200:
+        return "unreachable", None
+    try:
+        payload = dict(response.json())
+    except Exception:
+        return "unreachable", None
+    if not payload.get("access_token"):
+        return "unreachable", None
+    if not payload.get("refresh_token"):
+        # RFC 6749 §6: no new refresh token issued means the old one stays valid.
+        payload["refresh_token"] = refresh_token
+    try:
+        return "ok", _persist_tokens(payload)
+    except Exception:
+        return "unreachable", None
+
+
+def refresh(refresh_token: str) -> dict | None:
+    """Exchange a refresh token for a fresh access token.
+
+    The server rotates refresh tokens, so the response carries a new one that
+    replaces the old. A failure here means the token was revoked or replayed
+    and the user has to sign in again.
+    """
+    return _renew(refresh_token)[1]
 
 
 def login(notify: Callable[[str], Any] = print, force_browser: bool = False) -> str | None:
@@ -379,6 +405,37 @@ def access_token(notify: Callable[[str], Any] = print) -> str:
     return ""
 
 
+def session_status(renew: bool = True) -> str:
+    """Is this machine signed in to a Dulus account? Never prompts.
+
+    ``"active"``      a live session, or a ``dulus_sk_*`` key in DULUS_API_KEY
+    ``"offline"``     a session exists but its renewal couldn't reach Dulus —
+                      let the person keep working
+    ``"invalid_key"`` DULUS_API_KEY is set but isn't a Dulus key
+    ``"none"``        never signed in, signed out, or Dulus refused the renewal
+
+    With ``renew`` it talks to Dulus only when the access token has expired —
+    the same renewal :func:`access_token` runs on first use anyway. Without it
+    (background children, scripts) a stored refresh token is taken at its word
+    and renewed lazily, so parallel launches never race to rotate it.
+    """
+    explicit = (os.environ.get("DULUS_API_KEY") or "").strip()
+    if explicit:
+        looks_right = explicit.startswith(API_KEY_PREFIX) and len(explicit) >= len(API_KEY_PREFIX) + 16
+        return "active" if looks_right else "invalid_key"
+
+    store = load_store()
+    if store.get("access_token") and not _token_expired(store):
+        return "active"
+    refresh_token = store.get("refresh_token")
+    if not refresh_token:
+        return "none"
+    if not renew:
+        return "active"
+    state, _ = _renew(refresh_token, timeout=10)
+    return {"ok": "active", "refused": "none"}.get(state, "offline")
+
+
 def auth_headers(notify: Callable[[str], Any] = print) -> dict:
     """Authorization header for Dulus API calls, or empty when signed out."""
     token = access_token(notify)

{dulus-3.14.18 → dulus-3.15.0}/providers.py

@@ -3801,7 +3801,11 @@ def messages_to_anthropic(messages: list) -> list:
                     "name":  tc["name"],
                     "input": tc["input"],
                 })
-            result.append({"role": "assistant", "content": blocks})
+            # An empty assistant turn (reasoning-only stall) has no blocks, and
+            # Anthropic rejects empty content. Skip it — the API merges the
+            # surrounding consecutive user turns.
+            if blocks:
+                result.append({"role": "assistant", "content": blocks})
             i += 1
 
         elif role == "tool":
@@ -3890,11 +3894,15 @@ def messages_to_openai(messages: list, ollama_native_images: bool = False, model
             result.append(msg_out)
 
         elif role == "assistant":
-            msg: dict = {"role": "assistant", "content": m.get("content") or None}
+            tcs = m.get("tool_calls", [])
+            # null content is only legal next to tool_calls. A reasoning-only
+            # stall leaves an empty assistant turn in history; sending it as
+            # null 400s every later request in the session.
+            msg: dict = {"role": "assistant",
+                         "content": m.get("content") or (None if tcs else "")}
             if "thinking" in m and m["thinking"]:
                 msg["reasoning_content"] = m["thinking"]
             
-            tcs = m.get("tool_calls", [])
             if tcs:
                 msg["tool_calls"] = []
                 for tc in tcs:

{dulus-3.14.18 → dulus-3.15.0}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.14.18"
+version = "3.15.0"
 description = "Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS."
 readme = "README.md"
 requires-python = ">=3.10"

dulus-3.15.0/tests/test_empty_assistant_turn.py

@@ -0,0 +1,38 @@
+"""A reasoning-only stall leaves an empty assistant turn in history.
+
+agent.run keeps {"role": "assistant", "content": "", "tool_calls": []} after
+the model spends its whole budget on reasoning. Both converters must turn it
+into something the API accepts, or every later prompt in the session 400s.
+"""
+from __future__ import annotations
+
+import providers
+
+STALL = [
+    {"role": "user", "content": "Prove the theorem."},
+    {"role": "assistant", "content": "", "thinking": "", "tool_calls": []},
+    {"role": "user", "content": "Try again, shorter."},
+]
+
+
+def test_openai_empty_assistant_gets_string_content():
+    out = providers.messages_to_openai(STALL)
+    assert out[1] == {"role": "assistant", "content": ""}
+
+
+def test_openai_tool_call_turn_keeps_null_content():
+    msgs = [
+        {"role": "user", "content": "ls"},
+        {"role": "assistant", "content": "",
+         "tool_calls": [{"id": "c1", "name": "Bash", "input": {"command": "ls"}}]},
+        {"role": "tool", "tool_call_id": "c1", "name": "Bash", "content": "a.txt"},
+    ]
+    out = providers.messages_to_openai(msgs)
+    assert out[1]["content"] is None
+    assert out[1]["tool_calls"][0]["id"] == "c1"
+
+
+def test_anthropic_empty_assistant_is_dropped():
+    out = providers.messages_to_anthropic(STALL)
+    assert all(m["content"] for m in out)
+    assert [m["role"] for m in out] == ["user", "user"]