toolang 0.2.1__tar.gz → 0.2.2__tar.gz

{toolang-0.2.1 → toolang-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toolang
-Version: 0.2.1
+Version: 0.2.2
 Summary: A programming language and runtime for agents
 Project-URL: Homepage, https://toolang.ai/
 Project-URL: Documentation, https://toolang.ai/docs

{toolang-0.2.1 → toolang-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "toolang"
-version = "0.2.1"
+version = "0.2.2"
 description = "A programming language and runtime for agents"
 readme = "README.md"
 license = { file = "LICENSE" }

{toolang-0.2.1 → toolang-0.2.2}/src/toolang/cli/progress.py

@@ -83,6 +83,7 @@ class CliProgress:
                 for line in self._lines():
                     print(line, file=self._stream)
             self._print_summary()
+            self._reset_terminal_style()
 
     def interrupt(self) -> None:
         with self._lock:
@@ -290,6 +291,12 @@ class CliProgress:
         for summary in summaries:
             self._console.print(Text(summary, style="dim"))
 
+    def _reset_terminal_style(self) -> None:
+        if not self._console.is_terminal:
+            return
+        self._stream.write("\x1b[0m")
+        self._stream.flush()
+
     def _live_text(self) -> Text:
         text = Text()
         agent_items = [item for item in self._items.values() if item.kind == "agent"]

{toolang-0.2.1 → toolang-0.2.2}/src/toolang/cli/toolang/app.py

@@ -38,7 +38,6 @@ from ..utils import (
     _required_prefix_agent,
     _required_runtime_agent,
     _runtime_environ_for_agent,
-    _runtime_components,
     _runtime_value,
     _toolang_root,
     _ui_base_url,
@@ -401,6 +400,7 @@ def info_agent(
         ("Home", str(agents.agent_home(root, agent_name))),
         ("Caps", _info_caps_summary(root, agent_name)),
         ("Jobs", _info_jobs_summary(root, agent_name)),
+        ("Tools", _info_tools_summary(root, agent_name)),
         ("Models", _info_models_summary(root, agent_name, runtime_state=runtime_state, running=status.status != "stopped")),
         ("Status", status_value),
     ]
@@ -410,16 +410,12 @@ def info_agent(
         return
     if status.sandbox:
         rows.append(("Sandbox", status.sandbox))
-    if status.status == "running":
-        loops_text = _runtime_components(runtime_state)
-        if loops_text is not None:
-            rows.append(("Components", loops_text))
     message = _runtime_value(runtime_state.get("message"))
     pid_text = agents.runtime_pid_label(runtime_state)
     if pid_text is not None and status.status != "stopped":
         rows.append(("PID", pid_text))
-    if status.api_url:
-        rows.append(("API", status.api_url))
+    if status.endpoint:
+        rows.append(("API", status.endpoint))
     if status.webui_url:
         rows.append(("WebUI", status.webui_url))
     if status.status == "running" and started_at != "-":
@@ -875,19 +871,46 @@ def _info_models_summary(
     if running:
         raw_models = runtime_state.get("models")
         if isinstance(raw_models, list):
-            runtime_models = tuple(
+            selectors = tuple(
                 str(item).strip()
                 for item in raw_models
                 if isinstance(item, str) and item.strip()
             )
-            if runtime_models:
-                return ", ".join(runtime_models)
-    configured = agent_up.load_default_models(toolang_root, agent_name)
-    if configured:
-        return ", ".join(configured)
-    from ...models.resolution import DEFAULT_MODEL_SELECTOR
+            if selectors:
+                return _model_count_summary(
+                    toolang_root,
+                    agent_name,
+                    environ=dict(os.environ),
+                    selectors=selectors,
+                )
+    selectors = agent_up.load_default_models(toolang_root, agent_name)
+    return _model_count_summary(
+        toolang_root,
+        agent_name,
+        environ=dict(os.environ),
+        selectors=selectors,
+    )
+
 
-    return DEFAULT_MODEL_SELECTOR
+def _info_tools_summary(toolang_root: Path, agent_name: str) -> str:
+    rows = _tool_rows(toolang_root, dict(os.environ), agent_name=agent_name)
+    set_count = len({namespace for namespace, _tool, _description in rows})
+    return f"{len(rows)} {'tool' if len(rows) == 1 else 'tools'}, {set_count} {'set' if set_count == 1 else 'sets'}"
+
+
+def _model_count_summary(
+    toolang_root: Path,
+    agent_name: str,
+    *,
+    environ: dict[str, str],
+    selectors: Sequence[str] = (),
+) -> str:
+    rows = _model_rows(toolang_root, environ, agent_name=agent_name, model_selectors=selectors)
+    provider_count = len({provider for _model, provider, _details in rows})
+    return (
+        f"{len(rows)} {'model' if len(rows) == 1 else 'models'}, "
+        f"{provider_count} {'provider' if provider_count == 1 else 'providers'}"
+    )
 
 
 model_app = typer.Typer(
@@ -1032,13 +1055,14 @@ def _model_rows(
     root: Path,
     environ: dict[str, str],
     *,
+    agent_name: str = "",
     model_selectors: Sequence[str] = (),
 ) -> list[tuple[str, str, str]]:
     from ...models.config import load_model_aliases
     from ...models.views import model_list_rows
 
-    providers = agent_up.load_model_providers(root, "")
-    aliases = load_model_aliases(root, "")
+    providers = agent_up.load_model_providers(root, agent_name)
+    aliases = load_model_aliases(root, agent_name)
     return model_list_rows(
         providers=providers,
         aliases=aliases,
@@ -1066,12 +1090,13 @@ def _tool_rows(
     root: Path,
     environ: dict[str, str],
     *,
+    agent_name: str = "",
     tool_selectors: Sequence[str] = (),
 ) -> list[tuple[str, str, str]]:
     from ...config.plugins import load_tool_plugin_config
     from ...tools.views import tool_list_rows
 
-    config = load_tool_plugin_config(root, "", environ=environ)
+    config = load_tool_plugin_config(root, agent_name, environ=environ)
     tools = agent_up.load_tool_plugins(config=config)
     sources = _plugin_source_by_name("toolang.tool")
     return tool_list_rows(

{toolang-0.2.1 → toolang-0.2.2}/src/toolang/cli/utils.py

@@ -30,6 +30,7 @@ if TYPE_CHECKING:
 # weight so usage notes remain easy to read in terminal help output.
 setattr(typer_rich_utils, "STYLE_HELPTEXT", "")
 _TABLE_CONSOLE = Console(highlight=False, width=4096)
+_INFO_CONSOLE = Console(highlight=False)
 TableJustify = Literal["default", "left", "center", "right", "full"]
 _AGENT_AVATAR_CACHE: str | None = None
 _PALETTE_STYLES_CACHE: tuple[tuple[str, ...], tuple[str, ...]] | None = None
@@ -412,31 +413,39 @@ def _echo_pairs_table(
         collapse_padding=True,
     )
     table.add_column("FIELD", no_wrap=True, style="bold bright_cyan")
-    table.add_column("VALUE", no_wrap=False, style="white")
+    table.add_column("VALUE", no_wrap=False, style="white", overflow="fold")
     for key, value in rows:
         table.add_row(Text(key), _styled_info_value(key, value))
     typer.echo()
     if avatar is None:
         if title is None:
-            _TABLE_CONSOLE.print(table)
+            _INFO_CONSOLE.print(table)
         else:
-            _TABLE_CONSOLE.print(_info_title_block(title))
-            _TABLE_CONSOLE.print(table)
+            _INFO_CONSOLE.print(_info_title_block(title))
+            _INFO_CONSOLE.print(table)
     else:
-        layout = Table.grid(padding=(0, 4))
-        layout.add_column(no_wrap=True, ratio=0)
-        layout.add_column(no_wrap=False, ratio=1)
-        right = Table.grid(padding=(0, 0))
-        right.add_column(no_wrap=False)
         avatar_text = _rainbow_avatar_text(avatar)
-        if title is not None:
-            right.add_row(_info_title_block(title))
-            avatar_text = _rainbow_avatar_text("\n" + avatar)
-        right.add_row(table)
-        right.add_row(Text(""))
-        right.add_row(_palette_block())
-        layout.add_row(avatar_text, right)
-        _TABLE_CONSOLE.print(layout)
+        if _INFO_CONSOLE.width < 100:
+            _INFO_CONSOLE.print(avatar_text)
+            if title is not None:
+                _INFO_CONSOLE.print(_info_title_block(title))
+            _INFO_CONSOLE.print(table)
+            _INFO_CONSOLE.print(Text(""))
+            _INFO_CONSOLE.print(_palette_block())
+        else:
+            layout = Table.grid(padding=(0, 4))
+            layout.add_column(no_wrap=True, ratio=0)
+            layout.add_column(no_wrap=False, ratio=1)
+            right = Table.grid(padding=(0, 0))
+            right.add_column(no_wrap=False)
+            if title is not None:
+                right.add_row(_info_title_block(title))
+                avatar_text = _rainbow_avatar_text("\n" + avatar)
+            right.add_row(table)
+            right.add_row(Text(""))
+            right.add_row(_palette_block())
+            layout.add_row(avatar_text, right)
+            _INFO_CONSOLE.print(layout)
     typer.echo()
 
 

{toolang-0.2.1 → toolang-0.2.2}/src/toolang/config/log.py

@@ -8,6 +8,7 @@ import logging
 import logging.config
 from pathlib import Path
 import re
+import sys
 from typing import Any, Literal, cast
 
 from .log_spec import (
@@ -72,13 +73,21 @@ class MessageRegexFilter(logging.Filter):
         return bool(self._pattern.search(record.getMessage()))
 
 
-def build_uvicorn_log_config(*, spec: LogSpec | None = None, level: str = DEFAULT_LOG_LEVEL) -> dict[str, object]:
+def build_uvicorn_log_config(
+    *,
+    spec: LogSpec | None = None,
+    level: str = DEFAULT_LOG_LEVEL,
+    default_use_colors: bool | None = None,
+    access_use_colors: bool | None = None,
+) -> dict[str, object]:
     """Build one logging config shared by Uvicorn and runtime loggers."""
 
     ensure_custom_levels()
     log_spec = spec or resolve_log_spec(cli_value=level, environ={}, default=DEFAULT_LOG_LEVEL)
     root_level = level_name(log_spec.root_level)
     handler_level = level_name(log_spec.handler_level)
+    default_colors = _stream_uses_colors(sys.stderr) if default_use_colors is None else default_use_colors
+    access_colors = _stream_uses_colors(sys.stdout) if access_use_colors is None else access_use_colors
     return {
         "version": 1,
         "disable_existing_loggers": False,
@@ -87,13 +96,13 @@ def build_uvicorn_log_config(*, spec: LogSpec | None = None, level: str = DEFAUL
                 "()": "uvicorn.logging.DefaultFormatter",
                 "fmt": DEFAULT_LOG_FORMAT,
                 "datefmt": DEFAULT_LOG_DATE_FORMAT,
-                "use_colors": None,
+                "use_colors": default_colors,
             },
             "access": {
                 "()": "uvicorn.logging.AccessFormatter",
                 "fmt": DEFAULT_ACCESS_LOG_FORMAT,
                 "datefmt": DEFAULT_LOG_DATE_FORMAT,
-                "use_colors": None,
+                "use_colors": access_colors,
             },
         },
         "filters": {
@@ -169,7 +178,11 @@ def configure_logging(
         environ={} if environ is None else environ,
         default=DEFAULT_LOG_LEVEL,
     )
-    config = build_uvicorn_log_config(spec=log_spec)
+    config = build_uvicorn_log_config(
+        spec=log_spec,
+        default_use_colors=False if log_path is not None else None,
+        access_use_colors=False if log_path is not None else None,
+    )
     if log_path is not None:
         log_path.parent.mkdir(parents=True, exist_ok=True)
         handlers = cast(dict[str, object], config.get("handlers", {}))
@@ -238,6 +251,10 @@ def _logger_level_name(target: str, spec: LogSpec, *, default: int) -> str:
     return level_name(default if level is None else level)
 
 
+def _stream_uses_colors(stream: object) -> bool:
+    return bool(getattr(stream, "isatty", lambda: False)())
+
+
 def _install_message_filter(filter_obj: MessageRegexFilter) -> None:
     seen: set[int] = set()
     root = logging.getLogger()

{toolang-0.2.1 → toolang-0.2.2}/src/toolang/up.py

@@ -46,6 +46,7 @@ from toolang.tools.registry import (
 from .config.log import (
     DEFAULT_LOG_LEVEL,
     build_uvicorn_log_config,
+    configure_logging,
     configure_logging_plan,
     resolve_agent_logging,
 )
@@ -777,6 +778,8 @@ def _up_local(
     progress: ProgressSink | None = None,
     prepared_state: PreparedState | None = None,
 ) -> int:
+    runtime_log_spec = _runtime_log_spec_value(log_spec, environ)
+    configure_logging(spec=runtime_log_spec, environ=environ)
     loop_intervals_ms = dict(DEFAULT_TRIGGER_INTERVAL_MS)
     for component_name in component_group(TRIGGER_COMPONENTS, "trigger"):
         if component_name in loop_intervals_ms and loop_intervals_ms[component_name] <= 0:
@@ -884,7 +887,7 @@ def _up_local(
         app,
         host=host,
         port=port,
-        log_config=build_uvicorn_log_config(level=log_spec or DEFAULT_LOG_LEVEL),
+        log_config=build_uvicorn_log_config(level=runtime_log_spec or DEFAULT_LOG_LEVEL),
         shutdown_signal=shutdown_signal,
         on_starting=lambda: logger.info(
             "Agent starting root=%s trigger=%s runner=%s router=%s",
@@ -916,6 +919,13 @@ def _up_local(
     return 0
 
 
+def _runtime_log_spec_value(log_spec: str | None, environ: Mapping[str, str]) -> str | None:
+    if isinstance(log_spec, str) and log_spec.strip():
+        return log_spec.strip()
+    env_spec = environ.get(PY_LOG_ENV_VAR, "").strip()
+    return env_spec or None
+
+
 def _log_state_loaded(context: UptimeContext) -> None:
     state_logger.info(
         "Agent loaded state=%s models=%s tools=%s psyches=%s skills=%s services=%s",

{toolang-0.2.1 → toolang-0.2.2}/tests/test_cli.py

@@ -20,6 +20,7 @@ from toolang.base.types.tool import ToolContext, ToolDefinition
 import toolang.cli.toolang.app as cli
 import toolang.cli.caps.app as caps_cli
 import toolang.cli.caps.commands as caps_commands
+import toolang.cli.utils as cli_utils
 from toolang.cli.progress import CliProgress
 from toolang.components.trigger import watch
 from toolang.config.log import DEFAULT_AGENT_LOG_SPEC
@@ -2623,6 +2624,57 @@ def test_cli_info_shows_agent_details(tmp_path: Path, monkeypatch) -> None:
         "_utc_now",
         lambda: datetime(2026, 4, 8, 12, 0, 0, tzinfo=timezone.utc),
     )
+    monkeypatch.setattr(
+        cli.agent_up,
+        "load_model_providers",
+        lambda *_args: {
+            "openai": _FakeModelProvider(
+                name="openai",
+                models=(
+                    ModelInfo(
+                        ref="openai/o3",
+                        provider="openai",
+                        name="o3",
+                        model="o3",
+                        selectors=("o3", "openai/o3"),
+                        adapter="responses",
+                    ),
+                    ModelInfo(
+                        ref="openai/gpt-5",
+                        provider="openai",
+                        name="gpt-5",
+                        model="gpt-5",
+                        selectors=("gpt-5", "openai/gpt-5"),
+                        adapter="responses",
+                    ),
+                ),
+            ),
+        },
+    )
+    monkeypatch.setattr(
+        cli.agent_up,
+        "load_tool_plugins",
+        lambda *, config=None: {
+            "filesystem__read_text": _FakeLoadedTool(
+                plugin_name="filesystem",
+                leaf_name="read_text",
+                description="Read one text file.",
+            ),
+            "shell__execute": _FakeLoadedTool(
+                plugin_name="shell",
+                leaf_name="execute",
+                description="Run one shell command.",
+            ),
+        },
+    )
+    monkeypatch.setattr(
+        cli.agent_up,
+        "list_plugin_infos",
+        lambda *, group: [
+            cli.agent_up.PluginInfo(name="filesystem", source="built-in"),
+            cli.agent_up.PluginInfo(name="shell", source="external"),
+        ],
+    )
     caps.put_local_entry_text(
         toolang_root,
         "alice",
@@ -2677,7 +2729,8 @@ def test_cli_info_shows_agent_details(tmp_path: Path, monkeypatch) -> None:
     assert "alice" in result.stdout
     assert "-----" in result.stdout
     assert "Home" in result.stdout
-    assert str(toolang_root / "agents" / "alice") in result.stdout
+    assert result.stdout.index("▄▄▄▄▄▄▄▄▄") < result.stdout.index("ALICE") < result.stdout.index("Home")
+    assert str(toolang_root / "agents" / "alice") in "".join(result.stdout.split())
     assert "ROOM" not in result.stdout
     assert "PROGRAM" not in result.stdout
     assert "RUNTIME" not in result.stdout
@@ -2692,13 +2745,16 @@ def test_cli_info_shows_agent_details(tmp_path: Path, monkeypatch) -> None:
     assert "1 chore" in result.stdout
     assert "1 task" in result.stdout
     assert "Models" in result.stdout
-    assert "o3, gpt-5" in result.stdout
+    assert "2 models, 1 provider" in result.stdout
+    assert "Tools" in result.stdout
+    assert "2 tools, 2 sets" in result.stdout
+    assert result.stdout.index("Tools") < result.stdout.index("Models")
     assert "Status" in result.stdout
     assert "running (up a day)" in result.stdout
     assert "Sandbox" in result.stdout
     assert "none" in result.stdout
-    assert "Components" in result.stdout
-    assert "router.chat, runner.chat, trigger.pulse" in result.stdout
+    assert "Components" not in result.stdout
+    assert "router.chat, runner.chat, trigger.pulse" not in result.stdout
     assert "PID" in result.stdout
     assert str(os.getpid()) in result.stdout
     assert "Started" in result.stdout
@@ -2707,7 +2763,8 @@ def test_cli_info_shows_agent_details(tmp_path: Path, monkeypatch) -> None:
     assert "ONLINE" not in result.stdout
     assert "ENDPOINT" not in result.stdout
     assert "API" in result.stdout
-    assert "http://127.0.0.1:8765/docs" in result.stdout
+    assert "http://127.0.0.1:8765" in result.stdout
+    assert "http://127.0.0.1:8765/docs" not in result.stdout
     assert "WebUI" in result.stdout
     assert "https://too.run/8765" in result.stdout
     assert "Updated" not in result.stdout
@@ -2716,6 +2773,12 @@ def test_cli_info_shows_agent_details(tmp_path: Path, monkeypatch) -> None:
     assert result.stdout.index("Started") < result.stdout.index("Created")
 
 
+def test_cli_info_console_uses_terminal_width(monkeypatch) -> None:
+    monkeypatch.setenv("COLUMNS", "72")
+
+    assert cli_utils._INFO_CONSOLE.width == 72
+
+
 def test_cli_info_reads_cap_counts_from_prepared_locks(tmp_path: Path, monkeypatch) -> None:
     from toolang.state.prepared import write_prepared_lock
 
@@ -2878,7 +2941,7 @@ def test_cli_info_for_running_docker_sandbox_shows_container_pid(tmp_path: Path,
     assert result.stdout.index("PID") < result.stdout.index("API")
 
 
-def test_cli_info_prefers_runtime_models_for_active_agent(tmp_path: Path) -> None:
+def test_cli_info_prefers_runtime_models_for_active_agent(tmp_path: Path, monkeypatch) -> None:
     toolang_root = tmp_path / "toolang"
     agents.create_agent(toolang_root, "alice")
     (toolang_root / "agents" / "alice" / "config.toml").write_text(
@@ -2886,6 +2949,39 @@ def test_cli_info_prefers_runtime_models_for_active_agent(tmp_path: Path) -> Non
         'default = ["o3", "gpt-5"]\n',
         encoding="utf-8",
     )
+    monkeypatch.setattr(
+        cli.agent_up,
+        "load_model_providers",
+        lambda *_args: {
+            "anthropic": _FakeModelProvider(
+                name="anthropic",
+                models=(
+                    ModelInfo(
+                        ref="anthropic/claude",
+                        provider="anthropic",
+                        name="claude",
+                        model="claude",
+                        selectors=("claude", "anthropic/claude"),
+                        adapter="responses",
+                    ),
+                ),
+            ),
+            "openai": _FakeModelProvider(
+                name="openai",
+                models=(
+                    ModelInfo(
+                        ref="openai/gpt-5",
+                        provider="openai",
+                        name="gpt-5",
+                        model="gpt-5",
+                        selectors=("gpt-5", "openai/gpt-5"),
+                        adapter="responses",
+                    ),
+                ),
+            ),
+        },
+    )
+    monkeypatch.setattr(cli.agent_up, "load_tool_plugins", lambda *, config=None: {})
     agents.write_runtime_state(
         toolang_root,
         "alice",
@@ -2905,7 +3001,7 @@ def test_cli_info_prefers_runtime_models_for_active_agent(tmp_path: Path) -> Non
 
     assert result.exit_code == 0
     assert "Models" in result.stdout
-    assert "claude, gpt-5" in result.stdout
+    assert "2 models, 2 providers" in result.stdout
 
 
 def test_cli_channel_list_shows_installed_channels(monkeypatch) -> None:

{toolang-0.2.1 → toolang-0.2.2}/tests/test_log_config.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 import logging.config
 import re
+import sys
 from typing import cast
 
 from toolang.config.log import (
@@ -70,6 +71,25 @@ def test_build_uvicorn_log_config_keeps_http_debug_off_when_toolang_debug_is_ena
     assert loggers["httpcore"]["level"] == "OFF"
 
 
+def test_build_uvicorn_log_config_uses_formatter_stream_colors(monkeypatch) -> None:
+    class Tty:
+        def isatty(self) -> bool:
+            return True
+
+    class Plain:
+        def isatty(self) -> bool:
+            return False
+
+    monkeypatch.setattr(sys, "stderr", Tty())
+    monkeypatch.setattr(sys, "stdout", Plain())
+
+    config = build_uvicorn_log_config()
+
+    formatters = cast(dict[str, dict[str, object]], config["formatters"])
+    assert formatters["default"]["use_colors"] is True
+    assert formatters["access"]["use_colors"] is False
+
+
 def test_parse_log_level_accepts_warn_alias() -> None:
     assert parse_log_level("warn") == logging.WARNING
 
@@ -148,6 +168,22 @@ def test_configure_logging_supports_off_level(monkeypatch) -> None:
     assert loggers["httpx"]["level"] == "OFF"
 
 
+def test_configure_logging_disables_colors_for_file_logs(monkeypatch, tmp_path) -> None:
+    captured: dict[str, object] = {}
+
+    def fake_dict_config(config: dict[str, object]) -> None:
+        captured["config"] = config
+
+    monkeypatch.setattr(logging.config, "dictConfig", fake_dict_config)
+
+    configure_logging(spec="toolang.run=debug", environ={}, log_path=tmp_path / "agent.log")
+
+    config = cast(dict[str, object], captured["config"])
+    formatters = cast(dict[str, dict[str, object]], config["formatters"])
+    assert formatters["default"]["use_colors"] is False
+    assert formatters["access"]["use_colors"] is False
+
+
 def test_resolve_agent_logging_defaults_run_and_start_to_agent_spec(tmp_path) -> None:
     agent_log_path = tmp_path / "agent.log"
 

{toolang-0.2.1 → toolang-0.2.2}/tests/test_run_queue_runner.py

@@ -84,6 +84,7 @@ from toolang.caps import (
     remove_remote_entry,
 )
 from toolang.config.plugins import ChannelBinding
+from toolang.config.log_spec import PY_LOG_ENV_VAR
 from toolang.execution import execute as run_execute_module
 from toolang.execution.input import RunInput, bind_run_request
 from toolang.execution.runner import QueueRunner, RunOutcome, RunRequest, RunSubmission
@@ -2301,6 +2302,7 @@ def test_up_logs_runtime_urls_after_start_and_stop(tmp_path: Path, monkeypatch,
             on_stopped()
 
     monkeypatch.setattr("toolang.up._run_uvicorn_app", fake_run_uvicorn_app)
+    monkeypatch.setattr("toolang.up.configure_logging", lambda **_kwargs: None)
     caplog.set_level(logging.INFO, logger="toolang.runtime")
 
     result = run_experiments_up(
@@ -2330,6 +2332,50 @@ def test_up_logs_runtime_urls_after_start_and_stop(tmp_path: Path, monkeypatch,
     assert color_messages[1] == "Agent started webui=\x1b[1m%s\x1b[0m"
 
 
+def test_local_runtime_configures_logging_before_state_loaded(tmp_path: Path, monkeypatch) -> None:
+    toolang_root = tmp_path / "toolang"
+    agents.create_agent(toolang_root, "alice")
+    order: list[str] = []
+    captured: dict[str, object] = {}
+
+    def fake_configure_logging(*, spec: str | None, environ: dict[str, str], log_path=None) -> None:
+        del log_path
+        order.append("configure")
+        captured["spec"] = spec
+        captured["environ"] = environ
+
+    def fake_log_state_loaded(context: UptimeContext) -> None:
+        del context
+        order.append("state")
+
+    def fake_run_uvicorn_app(*args, **kwargs) -> None:
+        del args, kwargs
+        order.append("run")
+
+    monkeypatch.setattr(up_module, "configure_logging", fake_configure_logging)
+    monkeypatch.setattr(up_module, "_log_state_loaded", fake_log_state_loaded)
+    monkeypatch.setattr(up_module, "_run_uvicorn_app", fake_run_uvicorn_app)
+
+    result = up_module._up_local(
+        toolang_root=toolang_root,
+        agent_name="alice",
+        host="127.0.0.1",
+        endpoint_host="localhost",
+        port=8765,
+        enabled_components=("router.inspect",),
+        environ={PY_LOG_ENV_VAR: "toolang.state=info"},
+        sandbox_child=False,
+        model_selectors=(),
+        tool_selectors=None,
+        cap_selectors=(),
+        log_spec=None,
+    )
+
+    assert result == 0
+    assert order[:2] == ["configure", "state"]
+    assert captured["spec"] == "toolang.state=info"
+
+
 def test_state_loaded_log_counts_selectable_models(tmp_path: Path, caplog) -> None:
     toolang_root = tmp_path / "toolang"
     agents.create_agent(toolang_root, "alice")

{toolang-0.2.1 → toolang-0.2.2}/uv.lock

@@ -1729,7 +1729,7 @@ wheels = [
 
 [[package]]
 name = "toolang"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "dataclasses-json" },