toolang 0.3.2__tar.gz → 0.3.3__tar.gz

{toolang-0.3.2 → toolang-0.3.3}/PKG-INFO

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

{toolang-0.3.2 → toolang-0.3.3}/docs/api.md

@@ -448,15 +448,48 @@ Every successful query selects one projector after its subject resolves:
 | `records` | collection subject | summarized record rows | canonical record array |
 | `fields` | browsable Pointer value | direct child fields | exact selected value |
 | `value` | scalar, empty, resolved, or specialized value | rendered value | exact selected value |
+| `output` | Run with the explicit terminal name | complete result body | resolved result value |
 | `tree` | Run with the explicit terminal name | hierarchical durable execution | flat depth-first node array |
 | `call` | supported Step with the explicit terminal name | Step-owned historical call | normalized call or flat node array |
 
 `records`, `fields`, and `value` are implicit view kinds, not accepted command
-tokens. `tree` is explicit only on a whole Run. `call` is explicit only on a
-whole model, tool, run, par, or loop Step. Run and Step subjects never expose
+tokens. `tree` and `output` are explicit only on a whole Run. `call` is explicit
+only on a whole model, tool, run, par, or loop Step. Run and Step subjects never expose
 equivalent projector names, and the removed `model-call` spelling is not an
 alias.
 
+Read a Run's result with `output` (`too` is an alias for `toolang`):
+
+```sh
+too SCRIPT inspect run_ab12 output
+too SCRIPT inspect run_ab12 output | rich -m
+too SCRIPT inspect run_ab12 output | jq '.'
+too SCRIPT inspect run_ab12 output --json
+```
+
+`output` resolves stored references and removes the `Output` / `Local` wrappers.
+The default view writes Text unchanged and concatenates TextPart bodies in
+order for textual Parts. It preserves whitespace and Markdown source, adding
+only a final newline when nonempty text lacks one. Empty text and empty Parts
+emit no body. Structured values and nontext Parts emit complete indented JSON.
+The view does not render Markdown, add colors, wrap, or truncate content; use
+external tools such as `rich` or `jq` to present it. The `jq` example requires
+structured output or text that itself contains valid JSON.
+
+Textual Parts omit reasoning and nontext content from the default text view.
+The existing `--json` flag preserves every resolved Part and nested value;
+Text becomes a JSON string with its original whitespace. A JSON-looking Text
+value remains text and is never parsed to infer a type. `--human` and `--json`
+remain mutually exclusive; no new formatting flags are added. Output behavior
+is the same in a terminal and a pipe, including when `FORCE_COLOR` is set.
+
+A Run without an output fails with its ID and status instead of returning a
+blank success or waiting for completion. Present null and empty outputs succeed.
+Use `inspect RUN/output` to inspect the output wrapper, or
+`inspect RUN/output/local/value --json` for the raw stored value, including
+unresolved references. Existing Pointer queries retain their original behavior.
+The `output` projector is available only for whole Runs, not Steps or collections.
+
 `call` on a model Step reconstructs the complete normalized call persisted for
 that Step, including instructions, messages, tool definitions, the
 structured-output schema, and continuation data:
@@ -541,10 +574,11 @@ selected value retains normal Pointer resolution and validation.
 Human projections have no trailing context footer. Direct scalar and
 specialized values print only their value. Strings have no JSON quotes, and
 nullable Human type labels use `T?`. Multiline Part content stays aligned
-inside the VALUE cell without a leading bullet. `--json` does not resolve
-Pointers and prints only the selected canonical JSON value. The two display
-modes are mutually exclusive, and `--type` is not an option. Inspection is
-read-only and historical and does not load a runnable.
+inside the VALUE cell without a leading bullet. Pointer queries with `--json`
+do not resolve Pointers and print only the selected canonical JSON value. The
+explicit Run `output` view instead returns the resolved result as described
+above. Display modes are mutually exclusive, and `--type` is not an option.
+Inspection is read-only and historical and does not load a runnable.
 
 ## Runtime Commands
 

{toolang-0.3.2 → toolang-0.3.3}/docs/execution-presentation.md

@@ -53,12 +53,41 @@ Script and Chat use the same projected ownership, content, aggregates, facts,
 and errors. Their presenters own terminal mechanics such as wrapping, lane
 truncation, scrollback, and live-area replacement.
 
-A Run has no standalone progress header. A root Run contains projected Steps
-followed by one footer. Child Runs are represented through the Steps they
+The shared projector emits no standalone Run header. Script adds the root
+context header described below; Chat retains its existing run control bar.
+A root Run contains projected Steps followed by one footer. Child Runs are represented through the Steps they
 execute rather than separate Run headers or closure rows. A model-produced
 dynamic Run Step owns its own opening and closing divider around that child
 content.
 
+## Script Run Context
+
+Script prints one persistent context header to stderr when the root Run begins:
+
+```text
+‣ agic:review                  deepseek/deepseek-chat · auto
+```
+
+The entire header is dim on the terminal's default background. `‣` marks the
+start, with the runnable at the left edge and model/reasoning at the right edge
+of the configured progress width, separated by at least two spaces. Narrow
+layouts put model/reasoning below the runnable, with two-cell indentation;
+long fields wrap without truncation. A one- or two-cell viewport drops the
+marker and indentation. Terminal controls are escaped as literal text.
+
+The runnable uses the resolved root identity, displaying an unnamed entry as
+`agic:_` or `flow:_`. The model is the resolved initial run-level setting;
+Flow steps and child Runs may select other models. Reasoning shows an explicit
+effort or token budget, or `auto` when unspecified. A missing model request
+shows `model unspecified` with no reasoning field.
+
+The header appears once, before Step output, separated by one blank line. It
+remains in scrollback after success, failure, or cancellation. Preparation and
+submission failures before `RunBegin` produce no header. Nested Runs do not
+repeat it. Non-TTY output retains the layout without ANSI; `-q` suppresses it.
+Result saving, stdout, and the existing root footer are unchanged. Chat TUI
+does not display this Script header.
+
 ## Width and Alignment
 
 Progress is at most 120 terminal cells wide by default and never wider than an

{toolang-0.3.2 → toolang-0.3.3}/docs/input-syntax.md

@@ -26,10 +26,11 @@ ChatInput = QuickCommand | RunOverrideHelp | RunOverride + CallInput[str]
   chat input.
 - `RunOverrideHelp` is the terminal-chat-only `:?` interaction. It describes
   colon syntax without creating a run.
-- The runnable branch is valid only when it contains primary or named input. A
-  colon override without runnable input is invalid and never changes the
-  session. Slash setting commands change `SessionSetting` without creating a
-  run.
+- The runnable branch requires primary or named input, or an explicit runnable
+  selection (`:agic`, `:flow`, or `:runnable`). An explicit selection may invoke
+  a runnable with no input; its signature still validates required parameters.
+  Other colon overrides alone are invalid and never change the session. Slash
+  setting commands change `SessionSetting` without creating a run.
 
 Script, task, and chore surfaces parse the run-only pair of `RunOverride` and
 `CallInput[str]`; they do not parse `QuickCommand`. Agic, flow, and prompt
@@ -92,6 +93,11 @@ resolvable unqualified ref. `agic` and `flow` are exact shorthand:
 `default` resets only the generic runnable form. Kind-specific commands treat it
 as a normal name. Colon runnable commands may carry named runnable input, such
 as `:agic review focus=security`; slash runnable commands may not.
+`:flow research` invokes `research` with an empty argument map. It may be
+combined with other overrides, such as `:model effort=high` on a preceding
+line. `:runnable default` invokes the surface default, even if the session has
+selected another runnable. These forms do not synthesize an empty primary
+input; `:flow research -` instead supplies `_` as an empty string.
 
 Allow and limit bodies accept one or more assignments:
 
@@ -227,8 +233,10 @@ inside Script input still support fenced capture. The capture form is
 parser-only state and is not stored in `CallInput[str]`.
 
 Plain run-only parsing permits an empty `CallInput[str]` when the selected
-runnable accepts no primary or named input. A colon override still requires
-primary or named runnable input. Parsing is atomic: any invalid run override,
+runnable accepts empty input. Colon overrides also permit an empty argument map
+when they explicitly select a runnable; missing required input is rejected
+against that runnable's signature. Overrides without an explicit runnable still
+require primary or named input. Parsing is atomic: any invalid run override,
 named input, include, prompt, or coerced value rejects the complete input.
 
 ## Content

toolang-0.3.3/docs/plans/inspect-run-output.md

@@ -0,0 +1,108 @@
+# Inspect Run Output
+
+## Status
+
+Approved by the human on 2026-10-02: add only an `output` view that extracts
+content. Leave presentation to external tools and retain existing format flags.
+Implementation is authorized.
+
+## Goal And Success Criteria
+
+Read a Run result without its `Output` and `Local` storage wrappers. `too` is
+an alias for `toolang`.
+
+```sh
+too SCRIPT inspect RUN output
+too SCRIPT inspect RUN output | rich -m
+too SCRIPT inspect RUN output | rich --json
+too SCRIPT inspect RUN output | jq '.'
+too SCRIPT inspect RUN output --json
+```
+
+Text is emitted without interpretation; structured results are JSON. JSON
+renderers require structured output or text that itself contains valid JSON.
+The view does not perform presentation, colorization, wrapping, or truncation.
+
+## Baseline Behavior
+
+Before this feature, `inspect` supports `RUN tree`, `STEP call`, and canonical
+field Pointers such as `RUN/output/local/value`. Pointer JSON returns raw stored
+data without dereferencing it. `RunStore.resolve_local()` already resolves
+nested references and validates their types; this feature reuses that resolver.
+
+## Scope And Design
+
+Register `output` as a terminal projector for whole Runs alongside `tree`.
+Step, Thread, Control, collection, and field subjects reject it using existing
+allowed-view errors. Keep Pointer grammar and existing views unchanged. Do not
+add commands, formatting flags, aliases, latest-Run selection, Run-ID prefixes,
+or implicit script selection.
+
+Within the existing inspection read transaction, resolve `run.output.local`
+and serialize its `value` with `local_to_protocol_data()`. Omit binding, type,
+dimension, and synthetic envelopes. Preserve every nested field, list element,
+Part, and scalar type in JSON. This resolved JSON can differ from raw
+`RUN/output/local/value --json` when the stored result contains references.
+
+If the Run has no output, fail with exit code 1 and its ID and status, without
+writing a result to stdout. Present null and empty values succeed. Read any
+present output regardless of Run status; do not wait or infer a last-Step
+result. Missing Runs, broken references, cycles, and validation errors retain
+existing inspection error handling.
+
+## Output Contract
+
+| Resolved value | Default / `--human` | `--json` |
+| --- | --- | --- |
+| Text | Original text | JSON string |
+| Part / Part[] containing TextPart | Concatenated TextPart bodies in order | Complete serialized value |
+| Empty Part array | Empty body | Empty JSON array |
+| Other values, including nontext Parts | Complete indented JSON | Complete serialized value |
+
+Preserve text whitespace, tabs, Markdown, and code fences without trimming or
+rendering. Add a final newline only when nonempty text lacks one; empty text
+emits nothing. Textual Parts may omit reasoning and nontext content from their
+default view; JSON always preserves the full value. Use exact Part type
+compatibility rather than a name suffix, so authored structs such as
+`ReportPart` remain structured data. Never parse strings to infer JSON types.
+
+Output is identical in terminals and pipes. Do not add ANSI codes, metadata
+headings, footers, width-based wrapping, or truncation, even under `FORCE_COLOR`.
+The existing `--human` and `--json` flags remain mutually exclusive. Raw Pointer
+inspection remains available for wrappers and provenance.
+
+## Touchpoints
+
+- `src/toolang/cli/toolang/commands/inspect.py`: projector registration,
+  resolution, content extraction, plain output, and registry-derived help.
+- `tests/unit/cli/test_inspect_subject_navigation.py`: grammar and registry.
+- `tests/unit/cli/test_inspect_rendering.py`: exact Part classification and
+  identical plain output on terminals and pipes.
+- `tests/integration/cli/test_local_core_commands.py`: offline acceptance.
+- `docs/api.md`: syntax, output contract, resolved JSON, and errors.
+
+No persistence, schema, execution, API, plugin, or entry-point changes are
+required. Historical script selection and execution-store opening are unchanged.
+
+## Acceptance Tests
+
+1. Text and textual Parts emit complete unrendered content. Assert exact
+   whitespace, Markdown, code fences, Unicode, and long-content preservation.
+2. Empty text emits nothing; whitespace-only text retains its whitespace.
+   JSON round-trips null, empty containers, scalars, Parts, and nested values.
+3. Terminal and piped output contain no added ANSI codes, including under
+   forced-color environments. Narrow terminal widths do not alter content.
+4. Nontext Parts and custom struct arrays, including empty `ReportPart[]`,
+   emit complete JSON instead of crashing or disappearing.
+5. Direct, chained, and nested references resolve. Missing targets, cycles,
+   and type errors fail without partial stdout; raw Pointer JSON is unchanged.
+6. Missing output reports Run/status context. Missing history creates no store.
+   Script inspection reads history without running the script.
+7. Only whole Runs accept `output`; existing format conflicts still fail.
+   Help lists the view without new options; Pointer, tree, and call views stay
+   compatible. The default lint, format, type, and full offline checks pass.
+
+## Risks And Open Questions
+
+Resolving large outputs can be expensive; retain the current unbounded
+inspection model. There are no remaining product questions.

toolang-0.3.3/docs/plans/script-run-context.md

@@ -0,0 +1,158 @@
+# Script Run Context
+
+## Status, goal, and success criteria
+
+Approved for implementation on 2026-10-02. The human confirmed the presentation
+decisions below and requested implementation and a pull request.
+
+Show the root runnable and resolved run-level model configuration when Script
+execution starts. Users can identify the run before its first output and retain
+that context in terminal scrollback and redirected progress logs.
+
+## Verified current behavior
+
+- Chat's `RunControlBlock` shows runnable, request model, and reasoning. Its
+  foreground `▮` marker is bright cyan, on the input surface background.
+- Script's `ScriptRunPresenter._begin_root` creates a `RunBlock` without
+  printing it. Projected Steps are followed by a root footer on `RunEnd`.
+- Script progress uses stderr by default for both TTY and non-TTY streams;
+  `-q` suppresses it. Non-TTY progress is append-only and ANSI-free.
+- `RunBegin` contains the runnable but no model. Local `resolve_spec` supplies
+  `spec.model_request`; remote execution constructs a concrete `RunRequest`
+  before dispatch. Presentation can receive this context without new events.
+
+## Proposed presentation
+
+Print one stable context header immediately before the root's first projected
+Step, triggered by its `RunBegin`:
+
+```text
+‣ agic:review                   deepseek/deepseek-chat · auto
+
+• Review output.
+
+▪︎ run_one succeeded               2s · 1 model · ↑340 ↓86
+```
+
+The model and metrics above are illustrative, not a command invocation.
+
+- Use `‣` to indicate the start of execution. Keep the entire header dim,
+  including marker, runnable, model, reasoning, and separators, on the
+  terminal's default background. Add no accent color or bold text.
+- Anchor `‣ RUNNABLE` at column zero, with one space after the marker. Anchor
+  `MODEL · REASONING` at the right edge of the available progress width, using
+  at least two spaces between the groups. There is no dot between the left and
+  right groups. This follows the existing root footer's two-ended alignment.
+  Add no box, filled background, horizontal rule, input echo, timer, or new
+  Run ID. The existing footer retains identity and metrics.
+- Keep one blank line between the header and subsequent progress; coordinate
+  with existing first-Step spacing to avoid duplicate gaps. An empty run keeps
+  one blank line between its header and footer. Add no leading blank line.
+- Print once and retain the header in scrollback. Do not put it in Rich Live,
+  repaint it on resize, or repeat it at completion.
+- Use the existing configured maximum progress width, capped by TTY width;
+  align to this content edge, not a wider terminal edge. If both groups cannot
+  fit with the two-space minimum gap, render the runnable first, then the
+  model/reasoning group on continuation lines, left-aligned two cells from the
+  left, matching the footer's narrow layout. Wrap by display cells, preferring
+  field boundaries; omit the separator when reasoning moves to its own line.
+  Hard-wrap a field that cannot fit; preserve its text rather than ellipsizing
+  model or runnable identities.
+  At widths of one or two cells, drop marker and indentation to preserve a
+  usable text area. Escape control characters and render values as literal text.
+- Non-TTY uses the same marker, fields, order, and wrapping, without ANSI or
+  cursor movement. Quiet mode prints no header; stdout remains unchanged.
+
+A narrow layout can therefore look like:
+
+```text
+‣ agic:review
+  deepseek/deepseek-chat · auto
+```
+
+## Context semantics and lifecycle
+
+- The header describes the root run's initial configuration, not the active
+  descendant or a guarantee that all model calls use that configuration.
+  Keep existing nested Run and Step presentation unchanged.
+- Use the root `RunBegin.runnable` and the same compact runnable display as
+  Chat, including `agic:_` for an unnamed entry. Do not expose generated entry
+  identities. If the event's runnable is empty, use the resolved submission
+  runnable; if neither exists, display `runnable unspecified`.
+- Pass the concrete local `spec.model_request` or remote `request.model` into
+  the Script presenter before dispatch. Do not display the raw CLI selector,
+  infer the model from the first model Step, or perform store/network reads in
+  event callbacks.
+- Show the resolved model ref and same reasoning display semantics as Chat,
+  falling back to `auto` when a model exists without explicit reasoning.
+  As in Chat, `auto` describes an unspecified reasoning setting; it does not
+  claim provider-reported effort. With no model request, show
+  `model unspecified` and omit reasoning, including for a model-free Flow.
+- Create the context before starting execution, but emit only on root
+  `RunBegin`. Validation, preparation, or submission failure before that event
+  produces no header. A root failure or cancellation after it retains the
+  header and existing terminal footer/error behavior.
+- Limit this change to Script invocation. Never display this header in Chat
+  TUI; its existing run control bar remains unchanged. Keep the header in the
+  Script presenter, outside the shared `ProgressProjector`. Retry/rerun and
+  presenter callers without supplied context retain their existing output.
+  Nested `RunBegin` events never create this header.
+
+## Scope and implementation touchpoints
+
+- `src/toolang/cli/toolang/commands/script.py`: supply local and remote resolved
+  context before dispatch, preserving quiet mode and cleanup.
+- `src/toolang/cli/common/script_progress/presenter.py`: accept optional
+  context and emit the header at root start.
+- `src/toolang/cli/common/script_progress/blocks.py`: own context rendering,
+  spacing, and width behavior through the existing `ProgressConsole`.
+- `tests/unit/cli/test_script_run_presenter.py` and
+  `tests/unit/cli/test_script_command.py`: renderer and context wiring coverage.
+- `tests/integration/cli/test_script_local.py` and
+  `tests/integration/cli/test_script_remote_execution.py`: offline parity and
+  stream behavior.
+- `docs/execution-presentation.md`: document the Script-owned root context
+  exception to the shared projector's no-Run-header contract.
+
+No new flags, dependencies, persisted fields, execution events, provider calls,
+per-Step model labels, or changes to result saving and exit codes.
+
+## Acceptance tests
+
+1. A root header appears exactly once before Step output; nested runs and
+   completion do not repeat it. Empty, failed, and canceled runs retain correct
+   spacing and their existing footer semantics.
+2. Local and remote paths display the resolved model and runnable after CLI,
+   session, and input overrides, including remote model selector materialization.
+   Local invocation retains its existing exact-model-ref requirement.
+3. Named and unnamed runnables, explicit reasoning, automatic reasoning, and
+   absent model requests follow the field rules. Child model changes do not
+   rewrite the root snapshot.
+4. TTY styling keeps the entire header dim on the default background. The
+   runnable starts at the left edge and model/reasoning ends at the progress
+   width, separated by at least two spaces. Non-TTY content is equivalent after
+   style removal and contains no ANSI or cursor controls.
+5. Long refs, wide Unicode, literal markup, control characters, and very narrow
+   widths fit the width budget without silently dropping identity text. Cover
+   the exact two-space threshold and stacked fallback, and verify marker width.
+6. Quiet mode and errors before `RunBegin` emit no header. stdout, result
+   saving, exit codes, and presenter callers without context are unchanged.
+   Chat TUI emits no Script context header and retains its existing control bar.
+7. Run the repository's default Ruff, formatting, ty, and offline pytest checks
+   before implementation commits. Definition-only verification checks source
+   accuracy, referenced paths, and `git diff --check`.
+
+## Tradeoffs, risks, and open questions
+
+A stable header remains useful in logs, but can scroll off-screen during long
+runs. A pinned bar would require another live surface and would not give
+non-TTY logs the same persistent context. Wrapping costs extra lines on narrow
+terminals in exchange for retaining complete model identity.
+
+The main semantic risk is confusing the root model setting with every model
+used by a Flow. Keep the documented snapshot meaning and do not label it as
+the currently executing model.
+
+The human selected `‣`, an entirely dim header, alignment at both ends, and
+Script-only visibility with no new header in Chat TUI, then approved
+implementation. No open questions remain.

{toolang-0.3.2 → toolang-0.3.3}/pyproject.toml

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

toolang-0.3.3/src/toolang/_build_info.json

@@ -0,0 +1,6 @@
+{
+  "dirty": false,
+  "revision": "a79c073ce2fcc26088c5ac1dfb1f93931ffe048c",
+  "schema": 1,
+  "source_version": "v0.3.3"
+}

{toolang-0.3.2 → toolang-0.3.3}/src/toolang/cli/common/execution_progress/rich_rendering.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Sequence
 from dataclasses import dataclass
 
+from markdown_it.token import Token
 from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
 from rich.markdown import (
     BlockQuote,
@@ -34,25 +35,22 @@ _STYLES: dict[ProgressTone, str] = {
     "warning": "yellow",
 }
 RUN_DIVIDER_WIDTH = 42
-TERMINAL_MARKDOWN_THEME = Theme({"markdown.code": "bold cyan"})
 _SCRIPT_CODE_BACKGROUND = "bright_black"
 _SCRIPT_CODE_FOREGROUND = "bright_white"
 
-_ANSI_CODE_THEME = Syntax.get_theme("ansi_dark")
-
 
 class _ProgressCodeTheme(SyntaxTheme):
-    """Use terminal-owned ANSI token colors on one configured surface."""
+    """Add a default foreground while preserving the syntax theme's tokens."""
 
-    def __init__(self, *, background: str, foreground: str | None) -> None:
-        self._background = background
+    def __init__(self, theme: SyntaxTheme, *, foreground: str) -> None:
+        self._theme = theme
         self._foreground = foreground
 
     def get_style_for_token(self, token_type: TokenType) -> Style:
-        return _ANSI_CODE_THEME.get_style_for_token(token_type)
+        return self._theme.get_style_for_token(token_type)
 
     def get_background_style(self) -> Style:
-        return Style(color=self._foreground, bgcolor=self._background)
+        return self._theme.get_background_style() + Style(color=self._foreground)
 
 
 class _ProgressHeading(Heading):
@@ -84,22 +82,45 @@ class _ProgressHorizontalRule(HorizontalRule):
 class _ProgressCodeBlock(CodeBlock):
     """Render fenced code with the shared terminal-native palette."""
 
+    @classmethod
+    def create(cls, markdown: Markdown, token: Token) -> _ProgressCodeBlock:
+        assert isinstance(markdown, _ProgressMarkdown)
+        lexer_name = (token.info or "").partition(" ")[0] or "text"
+        return cls(
+            lexer_name,
+            markdown.code_theme,
+            background=markdown.code_background,
+            foreground=markdown.code_foreground,
+        )
+
+    def __init__(
+        self,
+        lexer_name: str,
+        theme: str,
+        *,
+        background: str,
+        foreground: str | None,
+    ) -> None:
+        super().__init__(lexer_name, theme)
+        self.background = background
+        self.foreground = foreground
+
     def __rich_console__(
         self,
         console: Console,
         options: ConsoleOptions,
     ) -> RenderResult:
         code = str(self.text).rstrip()
-        foreground, separator, background = self.theme.partition("|")
-        if not separator:
-            background = self.theme
+        theme: str | SyntaxTheme = self.theme
+        if self.foreground is not None:
+            theme = _ProgressCodeTheme(
+                Syntax.get_theme(self.theme), foreground=self.foreground
+            )
         yield Syntax(
             code,
             self.lexer_name,
-            theme=_ProgressCodeTheme(
-                background=background,
-                foreground=foreground or None,
-            ),
+            theme=theme,
+            background_color=self.background,
             word_wrap=True,
             padding=(1, 2),
         )
@@ -208,6 +229,17 @@ class _ProgressMarkdown(Markdown):
         "table_open": _ProgressTableElement,
     }
 
+    def __init__(
+        self,
+        markup: str,
+        *,
+        code_background: str,
+        code_foreground: str | None,
+    ) -> None:
+        super().__init__(markup, code_theme="ansi_dark")
+        self.code_background = code_background
+        self.code_foreground = code_foreground
+
 
 def progress_block_renderable(
     block: ProgressBlock,
@@ -737,14 +769,21 @@ class _MarkdownRow:
         prefix = self.row.prefix
         prefix_width = display_width(prefix)
         content_width = max(1, width - prefix_width)
-        segments = console.render(
-            _ProgressMarkdown(
-                self.row.text,
-                code_theme=f"{self.code_foreground or ''}|{self.code_background}",
-            ),
-            options.update_width(content_width),
+        inline_code_style = console.get_style("markdown.code", default="none") + Style(
+            bgcolor=self.code_background
         )
-        lines = list(Segment.split_lines(segments))
+        with console.use_theme(
+            Theme({"markdown.code": inline_code_style}, inherit=False)
+        ):
+            segments = console.render(
+                _ProgressMarkdown(
+                    self.row.text,
+                    code_background=self.code_background,
+                    code_foreground=self.code_foreground,
+                ),
+                options.update_width(content_width),
+            )
+            lines = list(Segment.split_lines(segments))
         preserve_background = True
         while lines and not _line_has_content(
             lines[0], preserve_background=preserve_background

toolang-0.3.3/src/toolang/cli/common/model_formatting.py

@@ -0,0 +1,16 @@
+"""Pure model presentation shared by CLI surfaces."""
+
+from __future__ import annotations
+
+from toolang.base.types.model import ModelRequest
+
+
+def model_reasoning_value(model: ModelRequest) -> str | None:
+    """Return one explicit effort level or token budget for display."""
+
+    reasoning = model.reasoning
+    if reasoning is None:
+        return None
+    if reasoning.effort is not None:
+        return reasoning.effort
+    return str(reasoning.budget_tokens) if reasoning.budget_tokens is not None else None