From 73af334d1143102776c04738c2af2600bf07fea4 Mon Sep 17 00:00:00 2001
From: Daniel Han <danielhanchen@gmail.com>
Date: Wed, 15 Jul 2026 08:41:00 -0700
Subject: [PATCH] Studio: stream live tool output with SSE heartbeats, fix web
 page extraction, and surface interrupted turns (#7083)

* Studio: stream live tool output with SSE heartbeats and fix web page extraction

Server-side python/terminal tools now stream incremental stdout to the chat
UI while running (new tool_output SSE event), and every blocking tool
execution emits heartbeat keepalives so reverse proxies (Cloudflare tunnels
cap idle streams at ~100s) cannot drop the connection mid-turn. The tool
loop routes also emit a stall keepalive during silent prompt prefill between
tool iterations. The final role=tool message the model sees is byte-identical
to before, so tool-call parsing, nudging, and healing are untouched.

web_search page fetches now extract main content: GitHub repo root pages are
rewritten to the README API (with HTML fallback), hidden/aria-hidden client
error placeholders are dropped, conversion scopes to article/main, and known
boilerplate fragments are stripped. Non-HTML responses are returned raw
instead of being run through the HTML converter.

The frontend renders live-scrolling tool output inside running python and
terminal cards, and a chat stream that ends without a terminal signal now
surfaces an explicit interrupted state with a Retry action instead of
silently ending the turn.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: fix content-type sniffing, unlimited-timeout drain, and env parity in tool streaming

Content-Type sniffing: get_content_type() defaults to text/plain when the
header is absent, so the sniffing fallback never fired and header-less HTML
came back as raw markup. Report an empty type for a missing header and sniff
the body whenever the declared type is not HTML, so mislabeled text/plain
HTML pages are converted like before the extraction change.

Unlimited timeout drain: with tool_call_timeout disabled the old path used
communicate(timeout=None) and waited for EOF, but the streaming drain capped
the post-exit drain at a 5 second join, truncating output from a grandchild
that holds stdout open. When timeout is None, drain until EOF or the cancel
event fires; finite timeouts keep the bounded remaining-budget join.

Env parity: drop the PYTHONUNBUFFERED=1 injection on the streaming path so
the child invocation is byte-identical with and without streaming (the env
var was model-visible via os.getenv). Live streaming granularity now depends
on the child flushing; unflushed output arrives in ~8 KB chunks or at exit
and the final result is unchanged, with SSE heartbeats covering the gaps.

* Studio: stream tool-call arguments while the model writes them

A model writing a large tool call (a full python game is minutes of
generation) produced nothing on the stream: the structured path
accumulated delta.tool_calls fragments silently after the provisional
card, and the text path's DRAINING state consumed everything until
stream end. The user saw a dead Running spinner while the model was in
fact writing code, and the byte-silent SSE segment was also the window
where proxies drop the connection.

New tool_args SSE events stream the arguments as they generate. The
structured path forwards each fragment once a provisional card exists
(backlog first, so the card starts from the top of the call). The text
path sniffs the drained call for an enabled tool name and streams the
raw call text under the id the stream-end parser assigns its first call
(call_0), so the final tool_start reconciles the same card; the sniff is
gated on enabled names plus the provisional size floor, and prose or
ordinary JSON answers never spawn a card. The safetensors loop streams
the drained render_html call to its existing provisional card the same
way.

The chat adapter accumulates the raw stream per card and feeds a partial
JSON parse (call envelopes and stringified arguments unwrapped) into the
part's args, so the python and terminal cards render the code live and
the render_html canvas builds while streaming; both cards now say
Writing code / Writing command during this phase via useToolArgsStatus.
Display only: the parser input, the executed call, and the conversation
the model sees are byte-identical, covered by new loop-level tests for
the structured path, the text path, and the no-tool JSON answer.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: keep full tool output visible past the model cap; heal /mnt/data habits

Live testing surfaced two issues in the tool streaming UX.

First, a long python stdout ended in '... (truncated' in the finished
card: the model-visible result is capped by tools._truncate
(_MAX_OUTPUT_CHARS, previously 8000 chars) to protect the context
window, and the card rendered that capped text even though the live
stream had already shown everything. The cap stays (raised to 16000,
overridable via UNSLOTH_TOOL_RESULT_MAX_CHARS) but display and model
concerns are now split: the adapter preserves the accumulated live
stream on tool_end whenever it captured more than the final result, and
the finished python/terminal cards prefer it. The live-stream ceiling
rises from 16 KB to 400 KB (chunks batch per poll, so SSE stays cheap),
and both the live pane and the finished card render only the last 2000
lines with a Show all control so a huge output cannot jank the DOM. The
truncation notice now tells the model the user saw the full output and
that written files persist in the working directory. The final result
string remains byte-identical with and without streaming.

Second, models trained on ChatGPT code-interpreter transcripts write to
/mnt/data, which does not exist here (the sandbox CWD is a per-thread
persistent dir). Three layers, all identical across streaming and
non-streaming paths: the python/terminal tool descriptions gain one
sentence saying to use relative paths in the persistent CWD; a failed
execution whose output shows a missing-file error on a known
code-interpreter prefix (/mnt/data, /mnt/outputs, /home/sandbox,
/workspace) gets a model-visible retry hint appended after truncation
so it always survives; and a sitecustomize shim on the sandbox
PYTHONPATH remaps those prefixes onto the CWD in open()/os.makedirs()
with a one-line stderr notice, covering the python tool and any Python
launched from the terminal tool without touching the exec wrapper (so
tracebacks keep their line numbers). Bash-level file operations cannot
be redirected without root or mount namespaces, so they rely on the
description and the hint.

* Studio: fix hidden-element parsing, heartbeat gaps, and tool output id collisions

Review follow-ups on the tool streaming work:

- _html_to_md: treat any present hidden attribute value as hidden (it is an
  enumerated attribute whose invalid value default is the Hidden state, so
  hidden="false" is still hidden), and implement HTML5 optional end tags so
  an unclosed <p hidden> or <li hidden> ends at the next sibling start tag
  instead of swallowing every following sibling until the parent closes
- tool_stream_exec: keep heartbeats flowing after the live-output cap; a
  tool that keeps printing past the cap kept the queue non-empty, so neither
  tool_output nor heartbeat events were emitted and the SSE stream went
  silent past proxy idle timeouts
- routes/inference: forward tool heartbeats before the
  disable_parallel_tool_use drop window swallows events, so a dropped call
  that executes server-side cannot leave the Anthropic stream silent
- llama_cpp: close the provisional text tool card with a tool_end when the
  drained call fails to parse (DRAINING false-positive path), so the card
  cannot spin forever while the text is delivered as content
- tools: decode terminal output as utf-8 with errors=replace like the python
  tool; invalid bytes used to raise UnicodeDecodeError from communicate() on
  the non-streaming path and silently truncate the streaming reader, so the
  two paths diverged
- sitecustomize: patch io.open alongside builtins.open; pathlib Path.open,
  read_text and write_text call io.open directly and bypassed the remap
- frontend: scope the toolLiveOutput/toolFullOutput store keys by pane
  (modelType and pairId) and clear stale entries on tool_start; backend ids
  like call_0 repeat across turns and across concurrently streaming panes
  (compare mode), so a later turn or another pane could display the wrong
  preserved output, and run-end cleanup now clears only its own keys

Each backend fix carries a regression test that fails on the previous code;
the byte-identity tests between streaming and non-streaming stay green.

* Studio: keep tool failure status visible and truncation/remap notices truthful

Finished python/terminal cards preferred the fuller live stream by length
alone, so a tool that printed a lot then timed out or exited non-zero showed
the captured stdout but dropped the final result's status (timeout notice,
Exit code N). preferFullToolOutput now shows the stream when the result is
just its truncated prefix, and appends the result otherwise so the failure
tail always survives and the copy button copies both.

The result truncation notice claimed the user was shown the full output, but
the same wrapper serves non-streaming chat/API and direct execute_tool()
callers where nothing is streamed to anyone. The notice is now mode-neutral
and stays byte-identical with and without an output_callback, keeping the
streaming vs non-streaming invariant intact.

The sandbox sitecustomize shim now remaps /tmp/outputs into the working
directory only while it does not already exist, so a real /tmp/outputs the
user's own code created is never shadowed; /tmp/outputs also joins the
missing-path retry-hint list.

* Studio: suppress hidden void elements and keep live output scroll pinned only when at bottom

* Studio: drop capped tool output without concatenating; remap pathlib mkdir

Past the live-output cap stream_tool_execution built item + _drain_pending()
(the current chunk joined with every queued sibling) only to discard it in the
capped branch, so a chatty tool (yes, a tight print loop) could enqueue far
more than one poll interval of text and blow past the memory/CPU ceiling the
cap exists to enforce. Drain and drop queued items without building a combined
string, still counting each drain toward the heartbeat cadence so the SSE
keepalive survives.

Generated code often prepares code-interpreter paths with
Path('/mnt/data').mkdir(parents=True, exist_ok=True); pathlib drives that
through os.mkdir (not the patched os.makedirs) per component and, on
FileExistsError, probes the unpatched os.stat via Path.is_dir(), so the setup
raised before open() ever ran. Patch os.mkdir with the same remap and patch
Path.mkdir so the whole parents/exist_ok dance lands on the mapped working
directory and stays idempotent; real paths still pass through.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: generalize sandbox write remap and hint to any hallucinated absolute path

Models invent absolute paths from seeing their CWD (a DeepSeek run did
open('/home/ubuntu/Sandbox/flappy_bird.html', 'w') and died with
FileNotFoundError). A prefix list cannot enumerate these, so the sitecustomize
shim gains a write-mode fallback in open()/io.open(): when a write/create-mode
open targets an absolute path outside the CWD whose parent directory does not
exist, redirect it to the basename in the CWD and emit the same one-line stderr
notice, echoing the original path. The prefix remaps still run first (they cover
reads and preserve subpaths); read modes never hit the fallback so real system
files fail or succeed truthfully; bytes paths pass through. The fallback is not
applied to mkdir/makedirs/Path.mkdir, since creating an arbitrary absolute
directory can legitimately succeed on the host, and that decision is documented
in a comment.

The model-visible retry hint now echoes the real failing path (parsed from the
traceback tail) instead of the canned /mnt/data example, and fires for any
absolute path outside the working directory, not just the enumerated prefixes,
while a relative miss still gets no hint.

The shim wrapper still adds one frame to tracebacks that surface open() errors;
suppressing only our frame has no clean standard mechanism (a wrapper always
adds a frame), so the frame is left as an accepted compromise.

Tests: hallucinated absolute write remaps to the CWD basename across w/a/x/w+;
reads of a missing absolute path pass through untouched; writes to an existing
external dir pass through; prefix subpaths still preserved; end-to-end write
fallback lands the file in the sandbox workdir identically with and without
streaming; the hint echoes the actual path for convention and non-convention
absolute paths alike.

* Studio: kill exited process groups on drain; bound the over-cap output batch

_drain_process_output killed the process only via _kill_process_tree, which
short-circuits once the parent has exited, so a grandchild that inherited
stdout and outlived the parent was never signaled: a finite-timeout run could
return while it kept holding the pipe, and a timeout=None cancel left it
behind. Capture the setsid process group before waiting and SIGKILL that group
at both give-up points so the whole tree is torn down.

The streaming wrapper's first over-cap batch joined the current chunk with the
entire pending backlog before enforcing the live-output cap, so a chatty tool
could allocate far past the cap on the crossing batch. Bound the drain to the
remaining budget and drop the surplus in place, keeping the truncated output
byte-identical to joining everything.

* Studio: harden sandbox path healing and process/generator cleanup

Sandbox sitecustomize shim:
- Make the generalized write fallback collision-safe: never redirect an
  invented absolute path onto an already-present CWD file (refuse and let the
  original open raise FileNotFoundError, preserving the workspace file).
- Only w/a/x create a file; r+/rb+ are read-update modes that require the
  target to exist, so a bare + no longer trips the write fallback.
- Gate every convention-prefix remap (/mnt/data, /mnt/outputs, /home/sandbox,
  /workspace) on the prefix root being absent, so a real host mount is never
  shadowed; a miss under an existing real prefix passes through.
- Patch os.open so Path.touch and other low-level creators heal convention
  paths too, matching the Path.mkdir patch.

Local code execution (tools.py):
- Capture the setsid process group right after Popen (before any watcher can
  poll/reap the leader) and thread it through the cancel watcher and drain.
- Kill the captured group in the non-streaming python/terminal timeout branch
  so an exited leader no longer leaks a stdout-holding grandchild (matches the
  streaming drain path).
- Guard os.getpgid/os.killpg by platform so streamed execution no longer
  raises on Windows; fall back to single-pid kill.
- Judge missing-path hints against the executor's real workdir so a legitimate
  miss inside a project workspace outside the sandbox root is not mislabeled.

Tool streaming routes (routes/inference.py):
- Drain a pending next(gen) worker before closing the generator in the
  safetensors and Anthropic tool streams, so a disconnect no longer races
  gen.close() (generator already executing) or leaks the thread/generator.

HTML to markdown:
- Only drop boilerplate lines composed entirely of known furniture phrases so
  real prose that merely quotes one (for example "we use cookies to
  authenticate requests") is preserved.

Adds hermetic tests for each change.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: keep aside callouts, contain sandbox path remaps, and keepalive dropped Anthropic tool events

_html_to_md: stop dropping <aside> unconditionally. Documentation pages
render notes/warnings/examples as aside admonition callouts; those inside
the selected article/main scope are real content. A furniture aside outside
the scope is already excluded by the main-content pass.

sitecustomize: contain the code-interpreter path remap under the sandbox
CWD. A hallucinated habit path such as /mnt/data/../other_session/file no
longer escapes the per-conversation workdir; parent-traversal components in
the suffix are dropped and a '.'/'..' write-fallback basename is refused.

routes/inference: emit a rate-limited comment keepalive when the Anthropic
Messages stream drops tool_output/tool_args events. A chatty tool keeps the
generator busy so the stall keepalive never fires and the tool wrapper emits
heartbeats only while idle, which left the SSE stream silent past proxy idle
caps; the OpenAI passthrough paths forward these events, this path now keeps
the connection alive.

* Studio: bound the tool-output chunk that first crosses the live cap

_drain_queue joined the entire chunk that first crossed the live-output
cap before dropping the rest, so a single multi-megabyte line (or any
chunk dequeued once the budget was already met at max_chars <= 0) was
materialized in full only to be truncated away, defeating the memory
ceiling the cap enforces. Slice the crossing chunk to one character past
the budget: that preserves the caller's overflow signal and its
byte-identical truncation while dropping the arbitrarily large remainder
in place.

* Studio: scope missing-path hint to the failing line, keepalive dropped-call output, and preserve truncated tool streams over byte length

- tools._missing_path_hint: the code-interpreter convention-prefix trigger
  scanned the whole output, so a convention prefix mentioned only in a
  traceback frame (a /workspace project root) or printed by the user's code
  would add a misleading 'use a relative path' hint even when the actual
  FileNotFoundError was a relative or in-workdir path. Scope the convention
  test to the failing-path error line(s), matching _extract_missing_abs_path.

- _anthropic_tool_stream: the tool_output/tool_args rate-limited keepalive sat
  after the drop_until_tool_end skip, so under disable_parallel_tool_use a
  chatty second-or-later tool call was dropped whole with no keepalive, letting
  an idle proxy kill the SSE stream. Check the keepalive branch before the drop
  skip (like the heartbeat branch) so dropped-call output keeps the stream alive.

- preferFullToolOutput / chat-adapter: a truncated result can be longer than
  the live stream by byte count once its footer, an 'Exit code N:' notice, or an
  __IMAGES__ base64 tail is appended, so the length-only gate discarded the full
  stream and the finished card fell back to the truncated text. Add a shared
  truncation-aware shouldPreserveFullOutput used by both the write and read
  sites: preserve the stream whenever the result carries the truncation footer.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: skip the habit-path hint for real project paths under a convention prefix

* Kill captured process group on streamed wait-timeout

The streamed drain path's proc.wait() timeout branch only called
_kill_process_tree(proc). If the leader exits in the narrow window between
the wait timing out and _kill_process_tree sampling its pgid, that helper
short-circuits on the reaped leader and a stdout-holding grandchild in the
same group survives. Also kill the captured pgid there, matching the
non-streaming communicate() timeout path. Adds a hermetic regression test
that models the reaped-leader race by stubbing _kill_process_tree.

* Fix 3.10 pathlib write_text remap and honor cancel in finite drain

On Python < 3.11 pathlib routes Path.open / read_text / write_text through
a module-level accessor singleton whose open attribute captured the original
io.open at import time (_NormalAccessor.open = io.open). Patching io.open in
the sandbox shim therefore never reached that captured reference, so a
Path('/mnt/data/x').write_text(...) raised FileNotFoundError on 3.10 while
passing on 3.11+ (which dropped the accessor and calls io.open at call time).
Repoint _NormalAccessor.open at the same io.open wrapper via a staticmethod,
guarded so it is an idempotent no-op on 3.11+. Keep the test save/restore
helpers symmetric so the accessor is restored too, and add a hermetic
write_text/read_text remap test that covers every version.

Also honor cancellation while draining inherited stdout after the leader
exits. Once the leader is reaped the cancel watcher returns (its loop is
while proc.poll() is None), so the finite-timeout drain did one blocking
reader.join(timeout=remaining) that ignored cancel_event and kept draining a
chatty grandchild for the whole budget after a disconnect/Stop. Poll
cancel_event in 0.5s slices against a deadline like the timeout=None branch
and kill the captured process group promptly on cancel. The normal path still
reaches EOF on its own, so the streamed vs non-streamed result is unchanged.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: port no-tool stream keepalive/drain and fix subprocess/queue/extraction asymmetries

Streaming no-tool paths now match their tool twins:
- _anthropic_plain_stream, safetensors/MLX no-tool stream, and standard GGUF
  no-tool stream run next(gen) in a worker with a timed SSE keepalive loop so a
  long prompt prefill cannot leave the stream idle past a proxy cap.
- The Anthropic plain and safetensors/MLX no-tool teardowns now drain the
  pending next(gen) worker and close the generator on disconnect instead of
  leaking the suspended generator.

Other asymmetries:
- Non-streaming _python_exec/_bash_exec always drain via _drain_process_output
  (output_callback may be None) so a cancelled run reaps a stdout-holding
  grandchild that outlived the leader instead of blocking in communicate(). The
  joined bytes are identical to communicate(), so streamed vs non-streamed
  results stay byte-identical.
- _build_bypass_env installs the sitecustomize path shim on PYTHONPATH (prepend,
  keeping the operator's entries) so /mnt/data remap works in bypass mode too.
- GGUF forwards output_callback to execute_tool only when the callable accepts
  it (shared accepts_output_callback), matching safetensors and preserving
  legacy monkey-patched signatures.
- tool_stream_exec bounds accepted live output at the producer boundary so a
  chatty tool cannot grow the queue without limit under consumer backpressure
  and cannot keep the drain spinning and starve heartbeats.
- html_to_md implicit-close now searches past unclosed inline descendants so a
  hidden <p>/<li> is closed by a following block; main-content scoping gates on
  the largest single <article>/<main> so a swarm of tiny cards cannot pass the
  threshold in aggregate and displace the real main.
- preferFullToolOutput re-attaches the "Exit code N:" prefix to the fuller
  stream instead of appending the still-prefixed result, so a failed truncated
  tool no longer duplicates its stdout in the finished card.

Adds hermetic tests for each.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Preserve short live output on timed-out tools; strip inline-CSS-hidden subtrees and score truncated main-content scopes

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Tighten chat tool streaming comments and docstrings

* Keep HTML READMEs from the GitHub API and preserve interrupted tool output

Convert a 200 HTML README body from the GitHub README API to Markdown
instead of discarding it and falling back to the repo page chrome, and
promote captured live stdout to full output when a tool never reaches
tool_end (stream interrupted or cancelled) so the partial diagnostics
stay on the finished card.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: anchor HTML sniff, keep repeated sandbox writes, reuse textual tool ids

Anchor _looks_like_html to the leading doctype/tag so a Markdown README that
opens with a fenced HTML example stays Markdown (no html_to_markdown
corruption), while bare HTML fragments (<body>/<article>/<section>) are still
detected and converted on a missing/wrong Content-Type.

Let the sandbox write fallback re-serve a target it already healed for the same
invented absolute path, so iterative overwrites of a generated artifact stop
failing with FileNotFoundError while the anti-clobber guard still refuses
unrelated same-basename files.

Reconcile the first textual tool call carrying an explicit id onto the open
provisional TEXT card instead of spawning a duplicate card under that id.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: run implicit-close before skipping tags and keep leading README tables as Markdown

A skipped block (<nav>/<footer>) is an HTML5 optional-end-tag closer of an
open <p>, but handle_starttag returned before the implicit-close bookkeeping,
so a never-closed <p hidden> kept its hidden mark and swallowed every following
sibling. Run _close_implicit before the skip decision so the hidden mark is
released and trailing content renders.

Drop <table> (and its <thead>/<tbody>/<tr>/<td>/<th> children) from the
_looks_like_html leading set: Markdown READMEs routinely open with a raw HTML
<table> badge/layout row, and sniffing that as HTML collapsed the whole
Markdown body through html_to_markdown, exactly like the already-excluded
<div align>/<p align> layout headers.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: make bypass-permissions Popen double faithful to the unified drain path

The non-streaming _python_exec/_bash_exec now share _drain_process_output,
which reads proc.stdout in a reader thread and calls proc.wait(); the test
double only implemented communicate(), so bypass-mode bash returned an
AttributeError instead of the faked output. Give _FakeProc a readable stdout
pipe (yields the fake line then EOF), wait()/poll()/pid, so the test exercises
the real drain path on both the python and bash bypass branches.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: persist sandbox path heals across runs and suppress nested hidden lists

* Studio: run tool Python child unbuffered (-u) so unflushed prints stream live

A long-running snippet doing bare print() without flush=True never reached
the live-output pane: CPython block-buffers stdout when writing to a pipe, so
_drain_process_output's readline() saw nothing until the buffer filled or the
process exited. Launch the child with the interpreter -u flag so stdout is
unbuffered and each print streams as it is produced.

-u is applied unconditionally on both the streaming and non-streaming path, so
the child invocation stays byte-identical with and without streaming and the
final joined result is unchanged (buffering/timing only). Unlike the earlier
PYTHONUNBUFFERED=1 env injection that was removed, -u does not pollute the
child's os.environ and is not visible via os.getenv.

* Render only the selected main-content subtree in html_to_markdown

The main-content heuristic sized each <article>/<main> candidate
individually to pick the largest subtree, but then rendered every
matching tag in the document. A page with one real article plus
sibling related-post cards or comment threads passed the size gate on
the real article yet still emitted the unrelated siblings.

Size and render the same chosen subtree so only the selected
main-content subtree reaches the output.

* Studio: tighten chat-tool-streaming fix comments

* Studio: store tool-output-scope separators as unicode escapes

The pane-scope and tool-output-key separators were literal NUL (0x00) bytes, which made git treat the file as binary and hide its diff and blame. Write them as \u0000 escapes instead; the runtime key value is unchanged.

* Studio: bound tool-stream teardown when the client disconnects

stream_tool_execution ran its yield loop with no try/finally, so a gen.close() on client disconnect (GeneratorExit at a yield) skipped the worker join and never signalled cancellation. A tool that does not poll cancel_event mid-flight (web_search, MCP, search_knowledge_base) then kept request teardown blocked until the tool's own timeout. Thread the request cancel_event into the wrapper, set it only on the abnormal-exit path so a clean multi-tool turn is unaffected, and bound the worker join to a few seconds; the daemon worker cannot outlive the process.

* Studio: sandbox path remap no longer masks missing reads

The sandbox sitecustomize shim remapped code-interpreter prefixes (/mnt/data, /workspace, ...) onto the working directory for every open mode, including reads. A read of a path that truly did not exist was silently redirected onto a same-basename workdir file instead of raising on the path the model used, hiding real missing-input errors. Remap writes and creates as before, but remap a read only when the mapped workdir target already exists (re-reading a just-written artifact); otherwise keep the original absolute path so the failure stays truthful.

* Studio: bound web fetch with one overall deadline and cancellation

The web fetch applied timeouts per network operation, so a GitHub README API attempt plus its HTML fallback plus up to five redirect hops could run well past the tool timeout, and nothing aborted once the client had disconnected. Add a single wall-clock deadline shared across the API attempt, the fallback, every redirect hop and the body read, cap each hop's socket timeout at the time left on the budget, and poll cancel_event. SSRF host pinning, per-hop redirect revalidation, the five-hop cap and the size cap are unchanged.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: keep tool-stream teardown off the event loop on disconnect

The bounded worker join added for disconnect safety still ran on an abnormal close, so a client disconnect could wait the full join timeout; and the safetensors and Anthropic tool streams closed their generator synchronously on the event loop, unlike the GGUF path. On abnormal exit the daemon worker is abandoned, so join with a zero timeout instead of waiting; offload the safetensors and Anthropic gen.close to a thread to match GGUF; and surface a heartbeat as soon as cancel_event is set while the worker is silent so the route regains control at once instead of after a heartbeat interval.

* Studio: extend the web-fetch deadline to DNS, the body read, and search

The overall fetch deadline did not cover host resolution or the response body read, and query-mode web_search ignored cancellation. Resolve hosts (initial and every redirect) on a budget-polled helper so a slow or pre-cancelled getaddrinfo aborts on time; read the capped body in chunks with the budget re-checked between them so a slow-drip server cannot stretch a single read past the deadline; and gate the blocking DDGS query on cancel_event on both sides. SSRF host pinning, per-hop redirect revalidation, the five-hop cap and the size cap are unchanged.

* Studio: defer the sandbox remap notice and tighten os.open create flags

The one-shot remap notice fired while computing the mapping, so a read that kept its original path emitted a false notice and spent the notice a later genuine remap needed. Only emit it once _remap_open commits to the redirect. Separately, os.open classified O_TRUNC / O_APPEND without O_CREAT as creating, but those cannot create a missing file, so a missing target now stays truthful (only O_CREAT maps to the creating mode).

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: convert only genuine HTML README bodies, not Markdown with a leading block tag

The GitHub README API returns the raw file, almost always Markdown. _looks_like_html classified a Markdown README opening with a block tag (<ul>, <ol>, <dl>, <pre>, <blockquote>) as HTML, so _fetch_page_text ran it through html_to_markdown and collapsed its headings, lists and fenced code into a single line. Sniff the README body with a stricter document-level check (doctype or a leading <html>/<head>/<body>) so only a real .html README is converted; the general page path is unchanged.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Surface unclassified mid-stream Anthropic errors as SSE error events

The local Anthropic tool-stream and plain-stream paths called
_anthropic_stream_error_event(e) with force defaulting to False, so an
unclassified mid-stream failure (llama-server crash, decode OOM, a
dropped upstream socket) returned no event. The except block then fell
through to emitter.finish(), emitting a normal message_delta and
message_stop that masked a truncated turn as a clean finish.

Pass force = True at both fall-through sites so an unclassified failure
emits a 500 SSE error event and returns, matching the Anthropic
passthrough path that already forces it. Add regression tests covering
both stream paths.

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Studio: give each tool run a unique part id so finished cards keep their own output

Backend tool ids restart at call_0 every assistant response, and the
transient toolLiveOutput/toolFullOutput store maps were keyed by pane
scope plus that bare backend id. Two turns in the same pane therefore
shared one key: the stale-clear at tool_start only guards the forward
direction, so when a later call_0 finished and wrote its preserved full
output, every earlier still-mounted finished card reading the same key
re-rendered and displayed the newer tool's output instead of its own.

Mint one per-run-unique part id per backend id (call_0:<uuid>) and route
tool_start/output/args/end through a single resolver so all events for a
call resolve the same id. The durable part carries the unique id, so the
finished-card readers derive a collision-free key with no change, and the
awaiting-confirmation path keeps its own synthesized id. Outbound replay
stays paired (the assistant tool_call id and the role=tool result
tool_call_id both come from the part id) and gains unique ids across
turns, which strict providers require.

* Studio: tighten PR comments

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: danielhanchen <michaelhan2050@gmail.com>
---
 studio/backend/core/inference/_html_to_md.py  |  387 +++++-
 studio/backend/core/inference/llama_cpp.py    |  185 ++-
 .../core/inference/safetensors_agentic.py     |   80 +-
 .../core/inference/sandbox_site/__init__.py   |    6 +
 .../inference/sandbox_site/sitecustomize.py   |  313 +++++
 .../core/inference/tool_stream_exec.py        |  284 ++++
 studio/backend/core/inference/tools.py        |  915 ++++++++++--
 studio/backend/routes/inference.py            |  232 +++-
 .../backend/tests/test_anthropic_messages.py  |  378 +++++
 .../backend/tests/test_bypass_permissions.py  |   20 +-
 .../backend/tests/test_llama_cpp_tool_loop.py |  254 ++++
 .../tests/test_sandbox_sitecustomize.py       |  522 +++++++
 studio/backend/tests/test_sandbox_tools.py    |   22 +
 .../tests/test_tool_output_streaming.py       | 1234 +++++++++++++++++
 .../tests/test_tool_stream_generator_drain.py |   83 ++
 .../tests/test_web_fetch_extraction.py        | 1196 ++++++++++++++++
 .../src/components/assistant-ui/thread.tsx    |   14 +-
 .../components/assistant-ui/tool-group.tsx    |   27 +-
 .../assistant-ui/tool-live-output.tsx         |   63 +
 .../assistant-ui/tool-result-output.tsx       |   63 +
 .../assistant-ui/tool-ui-python.tsx           |   44 +-
 .../assistant-ui/tool-ui-terminal.tsx         |   51 +-
 .../src/features/chat/api/chat-adapter.ts     |  216 ++-
 .../src/features/chat/api/chat-api.ts         |   40 +-
 studio/frontend/src/features/chat/index.ts    |    5 +
 .../src/features/chat/runtime-provider.tsx    |   46 +-
 .../chat/stores/chat-runtime-store.ts         |   55 +
 .../src/features/chat/tool-output-scope.ts    |   95 ++
 28 files changed, 6563 insertions(+), 267 deletions(-)
 create mode 100644 studio/backend/core/inference/sandbox_site/__init__.py
 create mode 100644 studio/backend/core/inference/sandbox_site/sitecustomize.py
 create mode 100644 studio/backend/core/inference/tool_stream_exec.py
 create mode 100644 studio/backend/tests/test_sandbox_sitecustomize.py
 create mode 100644 studio/backend/tests/test_tool_output_streaming.py
 create mode 100644 studio/backend/tests/test_tool_stream_generator_drain.py
 create mode 100644 studio/backend/tests/test_web_fetch_extraction.py
 create mode 100644 studio/frontend/src/components/assistant-ui/tool-live-output.tsx
 create mode 100644 studio/frontend/src/components/assistant-ui/tool-result-output.tsx
 create mode 100644 studio/frontend/src/features/chat/tool-output-scope.ts

diff --git a/studio/backend/core/inference/_html_to_md.py b/studio/backend/core/inference/_html_to_md.py
index e7de4a5312..92471b9866 100644
--- a/studio/backend/core/inference/_html_to_md.py
+++ b/studio/backend/core/inference/_html_to_md.py
@@ -7,6 +7,11 @@ Minimal HTML-to-Markdown converter using only the standard library.
 Replaces the external ``html2text`` (GPL-3.0) dependency with a ~250-line
 ``html.parser.HTMLParser`` subclass. Covers headings, links, bold/italic,
 lists, tables, blockquotes, code blocks, and entity decoding.
+
+``main_content=True`` also applies a readability-style heuristic: scope
+conversion to the page's ``<article>`` (else ``<main>``) subtree when it
+carries substantial text, and strip known boilerplate fragments (skip-links,
+error placeholders, session banners, cookie prompts) from the result.
 """
 
 from __future__ import annotations
@@ -27,8 +32,138 @@ _SKIP_TAGS = frozenset(
         "math",
         "nav",
         "footer",
+        # Never-rendered / form-chrome elements, not page content.
+        "template",
+        "dialog",
+        "button",
+        "select",
+        "datalist",
     }
 )
+# <aside> is NOT skipped: docs use it for admonition callouts (real content);
+# page-furniture asides are excluded by the main-content scoping pass instead.
+
+# Void elements never produce an end tag, so they must not join the
+# open-element stack used to bound hidden subtrees.
+_VOID_TAGS = frozenset(
+    {
+        "area",
+        "base",
+        "br",
+        "col",
+        "embed",
+        "hr",
+        "img",
+        "input",
+        "link",
+        "meta",
+        "param",
+        "source",
+        "track",
+        "wbr",
+    }
+)
+
+
+def _style_hides_element(style: str) -> bool:
+    """True when an inline ``style`` sets ``display:none`` / ``visibility:hidden``.
+
+    Parsed per property so an unrelated value that merely contains ``none`` is
+    not misread as hidden."""
+    lowered = style.lower()
+    if "none" not in lowered and "hidden" not in lowered:
+        return False
+    for declaration in style.split(";"):
+        prop, sep, value = declaration.partition(":")
+        if not sep:
+            continue
+        prop = prop.strip().lower()
+        # Drop any !important flag and keep the first token of the value.
+        value = value.split("!", 1)[0].strip().lower()
+        if prop == "display" and value == "none":
+            return True
+        if prop == "visibility" and value == "hidden":
+            return True
+    return False
+
+
+def _is_hidden_element(attr_dict: dict) -> bool:
+    """True when the element is not rendered: ``hidden`` attribute,
+    ``aria-hidden="true"``, or an inline ``style`` hiding it. Such JS-only
+    placeholders ship in the HTML but must not reach the output. ``hidden`` is
+    enumerated: any present value (even ``hidden="false"``) means not rendered."""
+    if "hidden" in attr_dict:
+        return True
+    if (attr_dict.get("aria-hidden") or "").strip().lower() == "true":
+        return True
+    return _style_hides_element(attr_dict.get("style") or "")
+
+
+# HTML5 optional end tags: a listed start tag implicitly closes an open element
+# of the key type (as browsers do), else an unclosed ``<p hidden>``/``<li hidden>``
+# swallows every following sibling. Keys: closable elements; values: closers.
+_P_CLOSING_TAGS = frozenset(
+    {
+        "address",
+        "article",
+        "aside",
+        "blockquote",
+        "details",
+        "div",
+        "dl",
+        "fieldset",
+        "figcaption",
+        "figure",
+        "footer",
+        "form",
+        "h1",
+        "h2",
+        "h3",
+        "h4",
+        "h5",
+        "h6",
+        "header",
+        "hgroup",
+        "hr",
+        "main",
+        "menu",
+        "nav",
+        "ol",
+        "p",
+        "pre",
+        "section",
+        "table",
+        "ul",
+    }
+)
+_IMPLICIT_CLOSERS: dict = {
+    "p": _P_CLOSING_TAGS,
+    "li": frozenset({"li"}),
+    "dt": frozenset({"dt", "dd"}),
+    "dd": frozenset({"dt", "dd"}),
+    "tr": frozenset({"tr"}),
+    "td": frozenset({"td", "th", "tr"}),
+    "th": frozenset({"td", "th", "tr"}),
+    "option": frozenset({"option", "optgroup"}),
+    "optgroup": frozenset({"optgroup"}),
+}
+
+
+# Item tag -> container tags that re-scope it: a nested container makes an inner
+# item a descendant, not an optional-close sibling, so recovery must stop there
+# rather than close (and un-hide) the outer item and leak its nested content.
+_CLOSE_BARRIERS: dict = {
+    "li": frozenset({"ul", "ol", "menu"}),
+    "dt": frozenset({"dl"}),
+    "dd": frozenset({"dl"}),
+    "tr": frozenset({"table"}),
+    "td": frozenset({"table"}),
+    "th": frozenset({"table"}),
+    "option": frozenset({"select", "datalist"}),
+    "optgroup": frozenset({"select", "datalist"}),
+}
+
+
 _BLOCK_TAGS = frozenset(
     {
         "p",
@@ -51,13 +186,33 @@ _INLINE_EMPHASIS = {"strong": "**", "b": "**", "em": "*", "i": "*"}
 
 
 class _MarkdownRenderer(HTMLParser):
-    """HTMLParser subclass that emits Markdown tokens into a list."""
+    """HTMLParser subclass that emits Markdown tokens into a list.
 
-    def __init__(self):
+    ``scope_tags`` restricts emission to the subtree(s) of the given tags
+    (e.g. ``{"article"}``): outside them every handler is a no-op, which is
+    how the readability-style main-content pass drops page furniture.
+    """
+
+    def __init__(self, scope_tags: frozenset[str] | None = None):
         super().__init__(convert_charrefs = False)
         self._out: list[str] = []
         self._skip_depth: int = 0
 
+        # Main-content scoping: emit only while inside a scope tag.
+        self._scope_tags = scope_tags
+        self._scope_depth: int = 0
+
+        # Output boundaries per top-level scope element, so a caller can size each
+        # candidate alone and a swarm of tiny sibling cards can't clear the threshold.
+        self.scope_segments: list[str] = []
+        self._scope_seg_start: int | None = None
+
+        # Hidden-subtree tracking: stack of open non-void tags plus the indices
+        # where a hidden element started. End tags pop to the matching tag, so
+        # an omitted </p>/<li> close cannot leave the renderer stuck hidden.
+        self._open_tags: list[str] = []
+        self._hidden_marks: list[int] = []
+
         # Link state
         self._link_href: str | None = None
         self._link_text_parts: list[str] = []
@@ -150,16 +305,95 @@ class _MarkdownRenderer(HTMLParser):
     # ------------------------------------------------------------------
     # Tag handlers
     # ------------------------------------------------------------------
+    # Structural bookkeeping shared by every start tag (skip/hidden/scope).
+    def _close_implicit(self, tag: str) -> None:
+        """HTML5 optional-end-tag recovery for a start tag about to open.
+
+        Pops each implicitly-closed ancestor (and its hidden marks), scanning the
+        whole stack so an open ``<p>``/``<li>`` still closes under an unclosed inline
+        ``<span>``. Stops at a ``_CLOSE_BARRIERS`` container so recovery never crosses
+        a nested list/table/dl and leaks the outer item's hidden content. Runs even
+        for skipped ``<nav>``/``<footer>``, which also close ``<p>``."""
+        barriers = _CLOSE_BARRIERS.get(tag, ())
+        while True:
+            close_at = None
+            for i in range(len(self._open_tags) - 1, -1, -1):
+                name = self._open_tags[i]
+                if tag in _IMPLICIT_CLOSERS.get(name, ()):
+                    close_at = i
+                    break
+                # A barrier container re-scopes the item; stop before it.
+                if name in barriers:
+                    break
+            if close_at is None:
+                break
+            del self._open_tags[close_at:]
+            while self._hidden_marks and self._hidden_marks[-1] >= close_at:
+                self._hidden_marks.pop()
+
+    def _enter_tag(self, tag: str, attr_dict: dict) -> bool:
+        """Track open/hidden/scope state; return True when the tag's content
+        should be rendered (False = suppressed). Caller runs ``_close_implicit``
+        first so recovery also fires for skipped tags."""
+        if tag not in _VOID_TAGS:
+            self._open_tags.append(tag)
+            if _is_hidden_element(attr_dict):
+                self._hidden_marks.append(len(self._open_tags) - 1)
+        elif _is_hidden_element(attr_dict):
+            # Void elements never join the stack, so suppress a hidden one inline.
+            return False
+        if self._scope_tags is not None and tag in self._scope_tags:
+            if self._scope_depth == 0:
+                self._scope_seg_start = len(self._out)
+            self._scope_depth += 1
+        if self._hidden_marks:
+            return False
+        if self._scope_tags is not None and self._scope_depth == 0:
+            return False
+        return True
+
+    def _exit_tag(self, tag: str) -> bool:
+        """Pop to the matching open tag; return True when the end tag should
+        be rendered (False = it closed inside a hidden / out-of-scope region)."""
+        suppressed = bool(self._hidden_marks) or (
+            self._scope_tags is not None and self._scope_depth == 0
+        )
+        if tag not in _VOID_TAGS:
+            # Pop to the innermost matching open tag (recovers omitted closes).
+            for i in range(len(self._open_tags) - 1, -1, -1):
+                if self._open_tags[i] == tag:
+                    del self._open_tags[i:]
+                    while self._hidden_marks and self._hidden_marks[-1] >= i:
+                        self._hidden_marks.pop()
+                    break
+        if self._scope_tags is not None and tag in self._scope_tags and self._scope_depth > 0:
+            self._scope_depth -= 1
+            if self._scope_depth == 0 and self._scope_seg_start is not None:
+                self.scope_segments.append("".join(self._out[self._scope_seg_start :]))
+                self._scope_seg_start = None
+        return not suppressed
+
     def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
         tag = tag.lower()
 
+        if self._skip_depth:
+            # Inside a skipped subtree: only track nested skip depth.
+            if tag in _SKIP_TAGS:
+                self._skip_depth += 1
+            return
+
+        # Recover optional end tags before the skip decision: a skipped
+        # <nav>/<footer> still implicitly closes an open <p>, releasing its
+        # hidden mark so following siblings render.
+        self._close_implicit(tag)
+
         if tag in _SKIP_TAGS:
             self._skip_depth += 1
             return
-        if self._skip_depth:
-            return
 
         attr_dict = dict(attrs)
+        if not self._enter_tag(tag, attr_dict):
+            return
 
         if tag in _HEADING_TAGS:
             level = int(tag[1])
@@ -250,6 +484,9 @@ class _MarkdownRenderer(HTMLParser):
         if self._skip_depth:
             return
 
+        if not self._exit_tag(tag):
+            return
+
         if tag in _HEADING_TAGS:
             self._emit("\n\n")
 
@@ -308,8 +545,13 @@ class _MarkdownRenderer(HTMLParser):
     # ------------------------------------------------------------------
     # Text / entity handlers
     # ------------------------------------------------------------------
+    def _text_suppressed(self) -> bool:
+        if self._skip_depth or self._hidden_marks:
+            return True
+        return self._scope_tags is not None and self._scope_depth == 0
+
     def handle_data(self, data: str) -> None:
-        if self._skip_depth:
+        if self._text_suppressed():
             return
         if self._in_pre:
             self._pre_parts.append(data)
@@ -326,12 +568,12 @@ class _MarkdownRenderer(HTMLParser):
         self._emit(text)
 
     def handle_entityref(self, name: str) -> None:
-        if self._skip_depth:
+        if self._text_suppressed():
             return
         self._emit(html.unescape(f"&{name};"))
 
     def handle_charref(self, name: str) -> None:
-        if self._skip_depth:
+        if self._text_suppressed():
             return
         self._emit(html.unescape(f"&#{name};"))
 
@@ -366,6 +608,14 @@ class _MarkdownRenderer(HTMLParser):
             else:
                 self._out.append("\n\n" + prefixed + "\n\n")
 
+        # A scope left open by truncated HTML never reached _exit_tag, so its output
+        # never joined scope_segments and would score 0. Flush the still-open segment
+        # here (after the side-buffers) so a truncated main-content page is scored.
+        if self._scope_seg_start is not None:
+            self.scope_segments.append("".join(self._out[self._scope_seg_start :]))
+            self._scope_seg_start = None
+            self._scope_depth = 0
+
 
 # Post-processing
 def _cleanup(text: str) -> str:
@@ -399,17 +649,124 @@ def _cleanup(text: str) -> str:
     return "\n".join(out).strip()
 
 
-# Public API
-def html_to_markdown(source_html: str) -> str:
-    """Convert HTML to Markdown (headings, links, emphasis, lists, tables, blockquotes, code, entities).
+# Known boilerplate fragments stripped from main-content conversions, matched
+# only against short lines. Sources: GitHub page furniture / client-side error
+# placeholders, skip-links, cookie banners.
+_BOILERPLATE_FRAGMENTS = (
+    "skip to content",
+    "skip to main content",
+    "there was an error while loading",
+    "please reload this page",
+    "you can't perform that action at this time",
+    "you signed in with another tab or window",
+    "you signed out in another tab or window",
+    "you switched accounts on another tab or window",
+    "reload to refresh your session",
+    "you must be signed in to change notification settings",
+    "uh oh!",
+    "{{ message }}",
+    "this website uses cookies",
+    "we use cookies",
+    "accept all cookies",
+    "manage cookie preferences",
+)
+# Only shorter lines are eligible for boilerplate dropping; real content
+# sentences quoting a fragment run longer.
+_BOILERPLATE_MAX_LINE_CHARS = 300
 
-    ``<script>``, ``<style>``, and ``<head>`` are stripped entirely.
-    """
-    # Normalize line endings before parsing.
-    source_html = source_html.replace("\r\n", "\n").replace("\r", "\n")
-    renderer = _MarkdownRenderer()
+# Normalized furniture phrases for whole-segment matching. See _line_is_boilerplate.
+_BOILERPLATE_NORMALIZED = frozenset(
+    re.sub(r"\s+", " ", fragment).strip().casefold().rstrip(".!:")
+    for fragment in _BOILERPLATE_FRAGMENTS
+)
+
+
+def _line_is_boilerplate(line: str) -> bool:
+    """True only when a whole line is composed of known furniture phrases.
+
+    Splits on sentence terminators and requires every segment to be furniture, so a
+    line stacking several phrases is dropped while prose that merely quotes one is
+    kept (its other words leave a non-furniture segment)."""
+    normalized = re.sub(r"\s+", " ", line).strip().casefold()
+    if not normalized:
+        return False
+    segments = [segment.strip().rstrip(".!:") for segment in re.split(r"[.!]", normalized)]
+    segments = [segment for segment in segments if segment]
+    return bool(segments) and all(segment in _BOILERPLATE_NORMALIZED for segment in segments)
+
+
+def _strip_boilerplate_lines(text: str) -> str:
+    """Drop short lines that consist entirely of known page-furniture phrases.
+
+    Fenced code blocks are preserved verbatim: boilerplate never renders
+    inside ``<pre>``, while READMEs legitimately quote error strings."""
+    out: list[str] = []
+    in_fence = False
+    for line in text.split("\n"):
+        if line.lstrip().startswith("```"):
+            in_fence = not in_fence
+            out.append(line)
+            continue
+        if not in_fence and len(line) <= _BOILERPLATE_MAX_LINE_CHARS and _line_is_boilerplate(line):
+            continue
+        out.append(line)
+    # Collapse blank runs the dropped lines may have left behind.
+    return re.sub(r"\n{3,}", "\n\n", "\n".join(out)).strip()
+
+
+def _render(source_html: str, scope_tags: frozenset[str] | None) -> str:
+    renderer = _MarkdownRenderer(scope_tags = scope_tags)
     renderer.feed(source_html)
     renderer.close()
     renderer.flush_pending()
     raw = "".join(renderer._out)
     return _cleanup(raw)
+
+
+def _select_main_scope_render(source_html: str, tag: str) -> tuple[int, str]:
+    """Length and boilerplate-stripped render of the largest single ``<tag>``
+    subtree. Sizing candidates one at a time stops many tiny sibling cards from
+    clearing the threshold together, and returning that one subtree keeps
+    unrelated siblings (related cards, comment threads) out of the output."""
+    renderer = _MarkdownRenderer(scope_tags = frozenset({tag}))
+    renderer.feed(source_html)
+    renderer.close()
+    renderer.flush_pending()
+    best_len = 0
+    best_render = ""
+    for seg in renderer.scope_segments:
+        rendered = _strip_boilerplate_lines(_cleanup(seg))
+        if len(rendered) > best_len:
+            best_len = len(rendered)
+            best_render = rendered
+    return best_len, best_render
+
+
+# A scoped conversion below this size is judged not to be the page's main
+# content (e.g. an empty <article> stub) and the next candidate is tried.
+_MIN_MAIN_CONTENT_CHARS = 200
+
+
+# Public API
+def html_to_markdown(source_html: str, *, main_content: bool = False) -> str:
+    """Convert HTML to Markdown (headings, links, emphasis, lists, tables, blockquotes, code, entities).
+
+    ``<script>``, ``<style>``, and ``<head>`` are stripped entirely, as are
+    subtrees hidden from rendering (``hidden`` / ``aria-hidden="true"``).
+
+    ``main_content=True`` applies a readability-style heuristic for page
+    fetches: prefer the ``<article>`` subtree (GitHub renders READMEs there),
+    then ``<main>``, falling back to the whole document, and strip known
+    boilerplate fragments from the result.
+    """
+    # Normalize line endings before parsing.
+    source_html = source_html.replace("\r\n", "\n").replace("\r", "\n")
+    if main_content:
+        for scope_tag in ("article", "main"):
+            # Render only the chosen subtree so sibling <article>/<main>
+            # elements do not leak in once the largest passes the size gate.
+            length, rendered = _select_main_scope_render(source_html, scope_tag)
+            if length >= _MIN_MAIN_CONTENT_CHARS:
+                return rendered
+        return _strip_boilerplate_lines(_render(source_html, None))
+    return _render(source_html, None)
diff --git a/studio/backend/core/inference/llama_cpp.py b/studio/backend/core/inference/llama_cpp.py
index 6b6c5373eb..8f19973cda 100644
--- a/studio/backend/core/inference/llama_cpp.py
+++ b/studio/backend/core/inference/llama_cpp.py
@@ -301,6 +301,27 @@ def _gguf_has_genuine_tool_signal(text: str, signals, active_tools: list[dict])
     return False
 
 
+_TEXT_TOOL_NAME_RE = re.compile(r'"name"\s*:\s*"([\w.\-]+)"')
+_TEXT_TOOL_GEMMA_RE = re.compile(r"\s*call:([\w.\-]+)")
+_TEXT_TOOL_REHEARSAL_RE = re.compile(r"\s*([\w.\-]+)\s*\[ARGS\]")
+
+
+def _sniff_text_tool_name(text: str, enabled_names: set) -> str:
+    """Best-effort tool name from a partially drained TEXT tool call, gated on
+    enabled names so prose can never spawn a card. Used only to open the live
+    argument pane early; the authoritative parse still happens at stream end."""
+    m = _TEXT_TOOL_NAME_RE.search(text[:4096])
+    if m and m.group(1) in enabled_names:
+        return m.group(1)
+    m = _TEXT_TOOL_GEMMA_RE.match(text[:256])
+    if m and m.group(1) in enabled_names:
+        return m.group(1)
+    m = _TEXT_TOOL_REHEARSAL_RE.match(text[:256])
+    if m and m.group(1) in enabled_names:
+        return m.group(1)
+    return ""
+
+
 def _is_rehearsal_prefix(stripped: str, active_tools: list[dict]) -> bool:
     """True if ``stripped`` is a (possibly partial) prefix of ``NAME[ARGS]`` for an
     active tool -- the bare tool name arriving in its own chunk before ``[ARGS]{...}``.
@@ -8984,6 +9005,7 @@ class LlamaCppBackend:
           {"type": "content", "text": "token"}            -- streamed content tokens (cumulative)
           {"type": "reasoning", "text": "token"}          -- streamed reasoning tokens (cumulative)
         """
+        from core.inference.tool_stream_exec import accepts_output_callback, stream_tool_execution
         from core.inference.tools import (
             build_rag_autoinject,
             execute_tool,
@@ -9268,6 +9290,17 @@ class LlamaCppBackend:
                 provisional_started_tool_calls: dict[str, str] = {}
                 resolved_provisional_tool_call_ids: set[str] = set()
                 _suppress_visible_output = _forced_tool_call_pending
+                # Cards that already got their first tool_args event; later
+                # fragments stream individually so a big payload isn't a dead spinner.
+                arg_streamed_tool_call_ids: set[str] = set()
+                # TEXT tool-call path: a committed call's raw text streams to a
+                # provisional card under the parser's first-call id ("call_0"), so
+                # the final tool_start reconciles in place.
+                _text_args_call_start = -1
+                _text_args_streamed_upto = -1
+                _text_args_id = ""
+                _text_args_name = ""
+                _confirm_gated_iteration = bool(confirm_tool_calls) and not bypass_permissions
 
                 with self._open_stream(url, payload, cancel_event) as (
                     response,
@@ -9430,6 +9463,29 @@ class LlamaCppBackend:
                                                     provisional = True,
                                                 ),
                                             }
+                                        # Stream argument text so the UI shows the code being
+                                        # written: first event the backlog, later the fragment.
+                                        # Display only; accumulator untouched.
+                                        if current_id in provisional_started_tool_calls:
+                                            if current_id not in arg_streamed_tool_call_ids:
+                                                arg_streamed_tool_call_ids.add(current_id)
+                                                _args_backlog = tool_calls_acc[idx]["function"].get(
+                                                    "arguments", ""
+                                                )
+                                                if _args_backlog:
+                                                    yield {
+                                                        "type": "tool_args",
+                                                        "tool_call_id": current_id,
+                                                        "tool_name": current_name,
+                                                        "text": _args_backlog,
+                                                    }
+                                            elif func.get("arguments"):
+                                                yield {
+                                                    "type": "tool_args",
+                                                    "tool_call_id": current_id,
+                                                    "tool_name": current_name,
+                                                    "text": func["arguments"],
+                                                }
                                     continue
 
                                 # ── Reasoning tokens ──
@@ -9468,7 +9524,60 @@ class LlamaCppBackend:
                                     content_accum += token
 
                                     if detect_state == _S_DRAINING:
-                                        pass  # accumulate silently
+                                        # Accumulate silently for parsing, but stream the drained
+                                        # TEXT call to a provisional card. Gated on an enabled-name
+                                        # sniff + size floor so prose/small calls spawn no pane; id
+                                        # matches the first call so the final tool_start reconciles.
+                                        if (
+                                            not has_structured_tc
+                                            and not _confirm_gated_iteration
+                                            and _text_args_call_start >= 0
+                                        ):
+                                            if not _text_args_id:
+                                                _call_text = content_accum[_text_args_call_start:]
+                                                _sniffed = _sniff_text_tool_name(
+                                                    _call_text, _enabled_tool_names
+                                                )
+                                                if _sniffed and (
+                                                    _sniffed == "render_html"
+                                                    or len(_call_text)
+                                                    >= _PROVISIONAL_ARGS_MIN_CHARS
+                                                ):
+                                                    _text_args_id = "call_0"
+                                                    _text_args_name = _sniffed
+                                                    if (
+                                                        _text_args_id
+                                                        not in provisional_started_tool_calls
+                                                    ):
+                                                        provisional_started_tool_calls[
+                                                            _text_args_id
+                                                        ] = _sniffed
+                                                        yield {
+                                                            "type": "tool_start",
+                                                            "tool_name": _sniffed,
+                                                            "tool_call_id": _text_args_id,
+                                                            "arguments": {},
+                                                            "provenance": tool_event_provenance(
+                                                                provisional = True,
+                                                            ),
+                                                        }
+                                                    yield {
+                                                        "type": "tool_args",
+                                                        "tool_call_id": _text_args_id,
+                                                        "tool_name": _sniffed,
+                                                        "text": _call_text,
+                                                    }
+                                                    _text_args_streamed_upto = len(content_accum)
+                                            elif len(content_accum) > _text_args_streamed_upto:
+                                                yield {
+                                                    "type": "tool_args",
+                                                    "tool_call_id": _text_args_id,
+                                                    "tool_name": _text_args_name,
+                                                    "text": content_accum[
+                                                        _text_args_streamed_upto:
+                                                    ],
+                                                }
+                                                _text_args_streamed_upto = len(content_accum)
 
                                     elif detect_state == _S_STREAMING:
                                         if in_thinking:
@@ -9575,6 +9684,11 @@ class LlamaCppBackend:
                                             # without yielding. A live <think> prefix is
                                             # separate from it -- close that.
                                             detect_state = _S_DRAINING
+                                            # Call text begins at the held buffer
+                                            # (live arg display only; UI extracts the code).
+                                            _text_args_call_start = len(content_accum) - len(
+                                                content_buffer
+                                            )
                                             if _close_streamed_think():
                                                 yield {
                                                     "type": "content",
@@ -9602,6 +9716,11 @@ class LlamaCppBackend:
                                                         "text": cleaned,
                                                     }
                                             detect_state = _S_DRAINING
+                                            # Live-arg display starts at the held buffer
+                                            # (visible prefix flushed above; UI extracts the code).
+                                            _text_args_call_start = len(content_accum) - len(
+                                                content_buffer
+                                            )
                                         elif _hold_buffer or (
                                             is_prefix
                                             and (
@@ -9849,9 +9968,20 @@ class LlamaCppBackend:
                             f"{'structured delta' if has_structured_tc else 'content text'}"
                         )
                     if not tool_calls:
-                        # DRAINING but no tool calls (false positive). Merge
-                        # accumulated metrics from prior tool iterations so
-                        # they aren't silently dropped.
+                        # DRAINING but no tool calls (false positive): close any
+                        # provisional cards (a sniff can open one whose call never
+                        # parses); without a tool_end the card spins forever.
+                        for _pid, _pname in provisional_started_tool_calls.items():
+                            if _pid not in resolved_provisional_tool_call_ids:
+                                resolved_provisional_tool_call_ids.add(_pid)
+                                yield {
+                                    "type": "tool_end",
+                                    "tool_name": _pname,
+                                    "tool_call_id": _pid,
+                                    "result": "",
+                                    "provenance": tool_event_provenance(provisional = True),
+                                }
+                        # Merge metrics from prior tool iterations so they aren't dropped.
                         yield {"type": "status", "text": ""}
                         if content_accum:
                             # Strip leaked tool-call XML before yielding.
@@ -9912,9 +10042,22 @@ class LlamaCppBackend:
                 assistant_msg: dict = {"role": "assistant", "content": content_text}
                 assistant_appended = False
 
+                # The text-path provisional card uses the parser's default id ("call_0");
+                # a Mistral-style call carries its own id and would open a duplicate. Reuse
+                # the card's id for the first matching call (same tool name) to reconcile.
+                _text_provisional_id = _text_args_id if not has_structured_tc else ""
+
                 for tc in tool_calls or []:
                     func = tc.get("function", {})
                     tool_name = func.get("name", "")
+                    if (
+                        _text_provisional_id
+                        and _text_provisional_id in provisional_started_tool_calls
+                        and _text_provisional_id not in resolved_provisional_tool_call_ids
+                        and tc.get("id") not in provisional_started_tool_calls
+                        and provisional_started_tool_calls[_text_provisional_id] == tool_name
+                    ):
+                        tc = {**tc, "id": _text_provisional_id}
                     provisional_match = tc.get("id") in provisional_started_tool_calls
                     decision = tool_controller.prepare_call(
                         tc,
@@ -10026,15 +10169,33 @@ class LlamaCppBackend:
                     ):
                         result = RAG_SEARCH_CAP_NUDGE
                     else:
-                        result = execute_tool(
-                            decision.tool_name,
-                            decision.arguments,
+                        # Execute in a worker thread so live stdout chunks and heartbeats
+                        # stream while the tool blocks (the SSE route turns heartbeats into
+                        # keepalives). Result is byte-identical to a direct call.
+                        def _invoke_tool(_output_callback, _decision = decision):
+                            # execute_tool is injectable and may be monkey-patched with the
+                            # pre-PR signature; forward output_callback only if it's accepted.
+                            kwargs = dict(
+                                cancel_event = cancel_event,
+                                timeout = _effective_timeout,
+                                session_id = session_id,
+                                thread_id = thread_id,
+                                rag_scope = rag_scope,
+                                disable_sandbox = bypass_permissions,
+                            )
+                            if accepts_output_callback(execute_tool):
+                                kwargs["output_callback"] = _output_callback
+                            return execute_tool(
+                                _decision.tool_name,
+                                _decision.arguments,
+                                **kwargs,
+                            )
+
+                        result = yield from stream_tool_execution(
+                            _invoke_tool,
+                            tool_name = decision.tool_name,
+                            tool_call_id = decision.tool_call_id,
                             cancel_event = cancel_event,
-                            timeout = _effective_timeout,
-                            session_id = session_id,
-                            thread_id = thread_id,
-                            rag_scope = rag_scope,
-                            disable_sandbox = bypass_permissions,
                         )
                         if decision.tool_name == "search_knowledge_base":
                             _kb_search_count += 1
diff --git a/studio/backend/core/inference/safetensors_agentic.py b/studio/backend/core/inference/safetensors_agentic.py
index c1fffb71cb..f4c243d1bf 100644
--- a/studio/backend/core/inference/safetensors_agentic.py
+++ b/studio/backend/core/inference/safetensors_agentic.py
@@ -15,6 +15,7 @@ parses tool calls from the cumulative text and dispatches via
 """
 
 import bisect
+import inspect
 import re
 import threading
 from typing import Callable, Generator, Optional
@@ -60,6 +61,7 @@ from core.inference.tool_loop_controller import (
     status_for_tool,
     tool_event_provenance,
 )
+from core.inference.tool_stream_exec import stream_tool_execution
 from state.tool_approvals import (
     TOOL_REJECTED_MESSAGE,
     abort_tool_decision,
@@ -402,6 +404,22 @@ def _tool_event_provenance(**flags: object) -> dict[str, object]:
     return tool_event_provenance(**flags)
 
 
+def _accepts_output_callback(func: Callable[..., str]) -> bool:
+    """Whether an injectable ``execute_tool`` supports ``output_callback``.
+
+    The loop's ``execute_tool`` is a parameter (tests inject fakes), so forward
+    the live-output kwarg only when the callable declares it or takes ``**kwargs``.
+    """
+    try:
+        sig = inspect.signature(func)
+    except (TypeError, ValueError):
+        return False
+    params = sig.parameters
+    if "output_callback" in params:
+        return True
+    return any(p.kind is inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+
 def _call_single_turn(single_turn, conversation: list, active_tools: list[dict]):
     """Call a single-turn generator with active tool schemas when supported."""
     try:
@@ -552,6 +570,9 @@ def run_safetensors_tool_loop(
         provisional_render_html_started = False
         provisional_resolved = False
         provisional_render_html_id = f"call_{next_call_id}"
+        # Live-args offset for the provisional render_html card: the drained call
+        # text streams as tool_args so the canvas shows the HTML being written.
+        _live_args_streamed_upto = -1
         # When a human confirmation gate is active the real tool_start is keyed
         # by an approval id and carries awaiting_confirmation, so an early
         # provisional card (keyed by tool_call_id, no approval) would show the
@@ -623,6 +644,30 @@ def run_safetensors_tool_loop(
                         "arguments": {},
                         "provenance": _tool_event_provenance(provisional = True),
                     }
+                    # Backlog first: everything drained so far.
+                    yield {
+                        "type": "tool_args",
+                        "tool_call_id": provisional_render_html_id,
+                        "tool_name": "render_html",
+                        "text": content_accum,
+                    }
+                    _live_args_streamed_upto = len(content_accum)
+                elif (
+                    provisional_render_html_started
+                    and not provisional_resolved
+                    and _live_args_streamed_upto >= 0
+                    and len(content_accum) > _live_args_streamed_upto
+                ):
+                    # Still writing the call: stream the fragment so the canvas
+                    # renders live. Display only; content_accum still feeds the
+                    # stream-end parser verbatim.
+                    yield {
+                        "type": "tool_args",
+                        "tool_call_id": provisional_render_html_id,
+                        "tool_name": "render_html",
+                        "text": content_accum[_live_args_streamed_upto:],
+                    }
+                    _live_args_streamed_upto = len(content_accum)
                 continue
 
             if detect_state == _state_streaming:
@@ -663,6 +708,13 @@ def run_safetensors_tool_loop(
                             "arguments": {},
                             "provenance": _tool_event_provenance(provisional = True),
                         }
+                        yield {
+                            "type": "tool_args",
+                            "tool_call_id": provisional_render_html_id,
+                            "tool_name": "render_html",
+                            "text": content_accum,
+                        }
+                        _live_args_streamed_upto = len(content_accum)
                     continue
                 cumulative_display = candidate
                 cleaned = strip_tool_markup_streaming(
@@ -819,6 +871,13 @@ def run_safetensors_tool_loop(
                         "arguments": {},
                         "provenance": _tool_event_provenance(provisional = True),
                     }
+                    yield {
+                        "type": "tool_args",
+                        "tool_call_id": provisional_render_html_id,
+                        "tool_name": "render_html",
+                        "text": content_accum,
+                    }
+                    _live_args_streamed_upto = len(content_accum)
             elif is_prefix and (is_rehearsal_prefix or len(stripped) < _MAX_BUFFER_CHARS):
                 # A rehearsal prefix is self-bounded; the buffer cap must not cut long MCP names short.
                 continue
@@ -1146,10 +1205,12 @@ def run_safetensors_tool_loop(
             ):
                 result = RAG_SEARCH_CAP_NUDGE
             else:
-                try:
-                    result = execute_tool(
-                        decision.tool_name,
-                        decision.arguments,
+                # Execute in a worker thread so live stdout chunks and heartbeats
+                # stream while the tool blocks (the SSE route turns heartbeats into
+                # keepalives). execute_tool is injectable; pass output_callback
+                # only when it accepts it.
+                def _invoke_tool(_output_callback, _decision = decision):
+                    kwargs = dict(
                         cancel_event = cancel_event,
                         timeout = eff_timeout,
                         session_id = session_id,
@@ -1157,6 +1218,17 @@ def run_safetensors_tool_loop(
                         rag_scope = rag_scope,
                         disable_sandbox = bypass_permissions,
                     )
+                    if _accepts_output_callback(execute_tool):
+                        kwargs["output_callback"] = _output_callback
+                    return execute_tool(_decision.tool_name, _decision.arguments, **kwargs)
+
+                try:
+                    result = yield from stream_tool_execution(
+                        _invoke_tool,
+                        tool_name = decision.tool_name,
+                        tool_call_id = decision.tool_call_id,
+                        cancel_event = cancel_event,
+                    )
                 except Exception as exc:
                     logger.exception("Tool %s raised: %s", decision.tool_name, exc)
                     result = f"Error: tool raised an exception: {exc}"
diff --git a/studio/backend/core/inference/sandbox_site/__init__.py b/studio/backend/core/inference/sandbox_site/__init__.py
new file mode 100644
index 0000000000..eea99aa526
--- /dev/null
+++ b/studio/backend/core/inference/sandbox_site/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+# Package marker only, so wheel builds ship this directory. It goes on the
+# sandbox PYTHONPATH so site machinery imports the sibling ``sitecustomize`` at
+# startup; nothing in the backend imports it directly.
diff --git a/studio/backend/core/inference/sandbox_site/sitecustomize.py b/studio/backend/core/inference/sandbox_site/sitecustomize.py
new file mode 100644
index 0000000000..d655e8e35a
--- /dev/null
+++ b/studio/backend/core/inference/sandbox_site/sitecustomize.py
@@ -0,0 +1,313 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Sandbox-side compatibility shim for ChatGPT code-interpreter paths.
+
+Models habitually write to /mnt/data (or /mnt/outputs, /home/sandbox,
+/workspace), none of which exist in the Studio sandbox. This module sits on the
+sandbox subprocess PYTHONPATH (see ``tools._build_safe_env``), so it loads at
+interpreter startup in every sandboxed ``python`` run and any Python the
+``terminal`` tool launches.
+
+It remaps those prefixes onto the CWD in ``open`` / ``io.open``, ``os.open``,
+``os.makedirs`` / ``os.mkdir`` and ``pathlib.Path.mkdir``. A write/create to a
+convention prefix always heals onto the CWD; a READ heals only when the mapped
+target already exists (re-reading an earlier write), so a genuinely missing
+input stays truthful on the path the model used instead of silently reading a
+same-basename workdir file. Since prefix lists cannot cover every invented path,
+``open`` / ``io.open`` also get a create-mode fallback: an absolute path outside
+the CWD whose parent is missing is redirected to the basename in the CWD. Reads
+and mkdir never use the fallback (an arbitrary absolute directory can legitimately
+succeed). It is collision-safe: it refuses to redirect onto an existing CWD file
+(letting open raise). The patch set (io.open, os.open, os.mkdir, Path.mkdir, and
+the <3.11 ``_NormalAccessor.open``) covers the low-level entry points pathlib
+routes through. A one-line stderr notice fires on the first remap, and everything
+is wrapped in try/except so a failure never breaks the interpreter.
+
+Identical with and without output streaming because the child env is.
+"""
+
+import builtins
+import io
+import json
+import os
+import sys
+
+# Code-interpreter convention prefixes. Remapping is gated on the prefix being
+# ABSENT (see _remap) so a genuine host mount / user dir is never shadowed.
+_PREFIXES = ("/mnt/data", "/mnt/outputs", "/home/sandbox", "/workspace")
+# /tmp exists on the host; separate only to note that. The absence gate applies alike.
+_CONDITIONAL_PREFIXES = ("/tmp/outputs",)
+_notified = False
+# Invented absolute write path -> healed CWD target, so re-writing the same
+# artifact re-serves it instead of tripping the anti-clobber guard.
+_remapped_writes: dict = {}
+# Each tool call is a fresh subprocess (in-process map starts empty), so this
+# on-disk sidecar carries the map across runs. It records only sources the
+# fallback healed, so an unrelated same-basename file is never adopted.
+_REMAP_SIDECAR = ".unsloth_sandbox_remap.json"
+
+
+def _note(subject, original, mapped):
+    """Print the one-shot stderr notice so the model learns the real location.
+
+    ``subject`` is what "does not exist" (the prefix, or the whole invented
+    path); ``original`` is echoed in the ``(original -> mapped)`` tail.
+    """
+    global _notified
+    if _notified:
+        return
+    _notified = True
+    print(
+        f"note: {subject} does not exist in this sandbox; "
+        f"using the working directory instead ({original} -> {mapped})",
+        file = sys.stderr,
+    )
+
+
+def _contained_join(cwd, rel):
+    """Join ``rel`` onto ``cwd`` so the result can never escape ``cwd``.
+
+    A habit path can carry ``..`` segments; joining verbatim would let the target
+    climb above the sandbox. ``..`` components are dropped and empty / ``.`` ones
+    ignored, keeping the result under ``cwd``.
+    """
+    parts = []
+    for part in rel.split("/"):
+        if part == "" or part == ".":
+            continue
+        if part == "..":
+            if parts:
+                parts.pop()
+            continue
+        parts.append(part)
+    return os.path.join(cwd, *parts) if parts else cwd
+
+
+def _map_onto_cwd(
+    prefix,
+    text,
+    notify = True,
+):
+    """Map ``<prefix>/rest`` onto ``./rest`` in the CWD, noting it once.
+
+    The suffix is contained under the CWD (see ``_contained_join``) so a path
+    like ``/mnt/data/../other_session/file`` cannot escape the workdir.
+    ``notify`` is False when the caller may keep the original path (a read), so
+    the one-shot notice is not spent on a remap that never happens.
+    """
+    rel = text[len(prefix) :].lstrip("/")
+    mapped = _contained_join(os.getcwd(), rel)
+    if notify:
+        _note(prefix, text, mapped)
+    return mapped
+
+
+def _sidecar_path(cwd):
+    return os.path.join(cwd, _REMAP_SIDECAR)
+
+
+def _load_sidecar(cwd):
+    """Return the persisted ``source -> healed target`` map, or {} on any error
+    (missing/corrupt/foreign sidecar degrades to in-process-only behaviour)."""
+    try:
+        with open(_sidecar_path(cwd)) as fh:
+            data = json.load(fh)
+    except Exception:  # noqa: BLE001 - a bad sidecar must never break user code
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _record_sidecar(cwd, source, target):
+    """Persist ``source -> target`` so the next run re-serves it.
+
+    Written atomically (temp + ``os.replace``) and wrapped so a read-only/full
+    filesystem never breaks the interpreter. The path is inside the CWD, so the
+    patched ``open`` leaves it untouched (no remap, no recursion).
+    """
+    try:
+        data = _load_sidecar(cwd)
+        if data.get(source) == target:
+            return
+        data[source] = target
+        tmp = _sidecar_path(cwd) + ".tmp"
+        with open(tmp, "w") as fh:
+            json.dump(data, fh)
+        os.replace(tmp, _sidecar_path(cwd))
+    except Exception:  # noqa: BLE001 - persistence is best effort only
+        pass
+
+
+def _is_creating_mode(mode):
+    """True only when an ``open()`` mode string can CREATE a missing file.
+
+    Only ``w`` / ``a`` / ``x`` create. ``r+`` / ``rb+`` require the path to exist,
+    so they must not trip the write fallback (which would corrupt an unrelated
+    same-basename file); ``w+`` / ``a+`` / ``x+`` still match.
+    """
+    return isinstance(mode, str) and any(c in mode for c in ("w", "a", "x"))
+
+
+def _remap_open(file, mode):
+    """Remap for ``open()`` / ``io.open()``.
+
+    A prefix remap runs first: a write/create heals onto the CWD; a READ heals
+    only when the mapped target already exists (re-reading an earlier write),
+    else the original path is kept so a genuine missing input fails truthfully
+    instead of silently reading a same-basename workdir file. Only if no prefix
+    matched and the call creates does the fallback kick in: an absolute target
+    outside the CWD whose parent is missing is redirected to the basename in the
+    CWD, unless ``CWD/<basename>`` already exists (an unrelated file), in which
+    case the original path is kept so open raises.
+    """
+    creating = _is_creating_mode(mode)
+    # notify=False: emit the notice only once we commit to the mapping below.
+    mapped = _remap(file, notify = False)
+    if mapped is not file:
+        # Write always heals; a read only when the mapped target exists (else keep
+        # the original path so a missing input stays truthful).
+        if creating or os.path.exists(mapped):
+            # Commit: emit the notice now (the notify=False peek above deferred it).
+            _remap(file, notify = True)
+            return mapped
+        return file
+    if not creating:
+        return file
+    try:
+        text = os.fspath(file)
+    except TypeError:
+        return file
+    # bytes paths left untouched (str-only, matching the prefix remaps).
+    if not isinstance(text, str) or not os.path.isabs(text):
+        return file
+    cwd = os.getcwd()
+    # Already inside the CWD: a real target the model meant; leave it alone.
+    if text == cwd or text.startswith(cwd + os.sep):
+        return file
+    parent = os.path.dirname(text)
+    # Redirect only when the parent is missing; an existing external directory is
+    # a deliberate target and stays truthful (os.path.exists follows symlinks).
+    if parent and os.path.exists(parent):
+        return file
+    base = os.path.basename(text)
+    # A trailing sep or '.'/'..' basename would redirect onto the CWD or its
+    # parent; refuse and let open raise.
+    if base in ("", ".", ".."):
+        return file
+    remapped = os.path.join(cwd, base)
+    # Never clobber an unrelated file sharing this basename (lexists catches
+    # dangling symlinks). But a target this fallback already healed for the same
+    # invented path (in-process map or cross-run sidecar) is the artifact being
+    # re-written, so re-serve it instead of raising on every overwrite.
+    if os.path.lexists(remapped) and remapped not in (
+        _remapped_writes.get(text),
+        _load_sidecar(cwd).get(text),
+    ):
+        return file
+    _remapped_writes[text] = remapped
+    _record_sidecar(cwd, text, remapped)
+    _note(text, text, remapped)
+    return remapped
+
+
+def _remap(path, notify = True):
+    """Map ``<prefix>/rest`` onto ``./rest`` in the CWD; other paths pass through.
+
+    ``notify`` is forwarded to ``_map_onto_cwd``; ``_remap_open`` passes False so
+    a read that keeps its original path emits no false notice.
+    """
+    try:
+        text = os.fspath(path)
+    except TypeError:
+        return path
+    if not isinstance(text, str):
+        return path
+    for prefix in _PREFIXES + _CONDITIONAL_PREFIXES:
+        # Heal only while the real prefix directory is absent, so a genuine host
+        # mount / user directory at that prefix is never shadowed.
+        if (text == prefix or text.startswith(prefix + "/")) and not os.path.exists(prefix):
+            return _map_onto_cwd(prefix, text, notify = notify)
+    return path
+
+
+def _install():
+    import pathlib
+
+    original_open = builtins.open
+    original_io_open = io.open
+    original_os_open = os.open
+    original_makedirs = os.makedirs
+    original_mkdir = os.mkdir
+    original_path_mkdir = pathlib.Path.mkdir
+
+    def _open(
+        file,
+        mode = "r",
+        *args,
+        **kwargs,
+    ):
+        return original_open(_remap_open(file, mode), mode, *args, **kwargs)
+
+    def _io_open(
+        file,
+        mode = "r",
+        *args,
+        **kwargs,
+    ):
+        return original_io_open(_remap_open(file, mode), mode, *args, **kwargs)
+
+    # mkdir/makedirs get only the prefix remap, never the write-mode fallback:
+    # an arbitrary absolute directory can legitimately succeed on the host.
+    def _makedirs(name, *args, **kwargs):
+        return original_makedirs(_remap(name), *args, **kwargs)
+
+    def _mkdir(path, *args, **kwargs):
+        return original_mkdir(_remap(path), *args, **kwargs)
+
+    def _os_open(
+        path,
+        flags,
+        mode = 0o777,
+        *,
+        dir_fd = None,
+    ):
+        # Path.touch() etc. go through os.open, not builtins.open. Only O_CREAT
+        # can create, so only it maps to "creating" mode; O_TRUNC / O_APPEND
+        # without O_CREAT still require the file to exist, so behave as a read.
+        logical_mode = "w" if (flags & os.O_CREAT) else "r"
+        mapped = _remap_open(path, logical_mode)
+        if dir_fd is None:
+            return original_os_open(mapped, flags, mode)
+        return original_os_open(mapped, flags, mode, dir_fd = dir_fd)
+
+    def _path_mkdir(self, *args, **kwargs):
+        # pathlib probes Path.is_dir()/os.stat (unpatched) on FileExistsError, so
+        # a bare os.mkdir remap would still raise when the target exists. Remap
+        # the receiver up front so parents/exist_ok stays idempotent.
+        mapped = _remap(self)
+        target = self if mapped is self else self.__class__(mapped)
+        return original_path_mkdir(target, *args, **kwargs)
+
+    builtins.open = _open
+    # pathlib.Path.open / write_text / read_text call io.open directly, so patch both.
+    io.open = _io_open
+    # Python < 3.11 only: pathlib's accessor captured the ORIGINAL io.open at
+    # import (``_NormalAccessor.open = io.open``), so the io.open patch misses it.
+    # Repoint it at the same wrapper (staticmethod to stay unbound); 3.11+ dropped
+    # the accessor, so this is a no-op there.
+    accessor = getattr(pathlib, "_NormalAccessor", None)
+    if accessor is not None and hasattr(accessor, "open"):
+        accessor.open = staticmethod(_io_open)
+    # Path.touch() and other low-level opens call os.open directly, so patch it too.
+    os.open = _os_open
+    os.makedirs = _makedirs
+    # Path.mkdir(parents=True) calls os.mkdir per component, so patch os.mkdir;
+    # patch Path.mkdir itself too so exist_ok/parents land on the mapped path.
+    os.mkdir = _mkdir
+    pathlib.Path.mkdir = _path_mkdir
+
+
+try:
+    _install()
+except Exception:  # noqa: BLE001 - a broken shim must never break user code
+    pass
diff --git a/studio/backend/core/inference/tool_stream_exec.py b/studio/backend/core/inference/tool_stream_exec.py
new file mode 100644
index 0000000000..9cdb21bf8a
--- /dev/null
+++ b/studio/backend/core/inference/tool_stream_exec.py
@@ -0,0 +1,284 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Streaming wrapper around blocking server-side tool execution.
+
+``stream_tool_execution`` runs a blocking tool call in a worker thread and
+turns it into a generator that yields:
+
+* ``{"type": "tool_output", "tool_name", "tool_call_id", "text"}`` -- an
+  incremental stdout/stderr chunk (python/terminal tools) for live UI output;
+* ``{"type": "heartbeat"}`` -- emitted whenever nothing else has been yielded
+  for ``heartbeat_interval_s`` seconds, so the SSE route can write a
+  keepalive and reverse proxies (Cloudflare tunnels cap idle streams at
+  ~100 s) never see a silent connection while a tool runs;
+
+and *returns* the tool's final result string via ``StopIteration.value``
+(``result = yield from stream_tool_execution(...)``). The returned result is
+byte-identical to calling the tool directly, so tool-result parsing, nudging,
+and healing downstream are untouched.
+"""
+
+from __future__ import annotations
+
+import inspect
+import queue
+import threading
+import time
+from typing import Any, Callable, Generator
+
+from loggers import get_logger
+
+logger = get_logger(__name__)
+
+
+def accepts_output_callback(func: Callable[..., str]) -> bool:
+    """Whether an injectable ``execute_tool`` supports ``output_callback``.
+
+    ``execute_tool`` is replaceable (tests inject fakes / the pre-PR signature),
+    so forward the kwarg only when the callable declares it or takes ``**kwargs``
+    (passing it unconditionally would ``TypeError`` on an old signature).
+    """
+    try:
+        params = inspect.signature(func).parameters
+    except (TypeError, ValueError):
+        return False
+    if "output_callback" in params:
+        return True
+    return any(p.kind is inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+
+# Cadence of heartbeat events while a tool blocks with no output. Well under
+# common proxy idle caps (Cloudflare ~100 s, nginx default 60 s).
+TOOL_HEARTBEAT_INTERVAL_S = 10.0
+
+# How often the wrapper wakes to poll for output / completion / cancellation.
+_POLL_INTERVAL_S = 0.25
+
+# Upper bound on how long teardown waits for the worker once the stream is
+# closed or errors. A cancel-observing tool returns within this after
+# ``cancel_event`` is set; a cancel-ignoring one is a daemon left to finish on
+# its own rather than blocking teardown for the tool's full timeout.
+_WORKER_JOIN_TIMEOUT_S = 5.0
+
+# Cap on total streamed live-output characters per tool call, bounding the
+# transient UI stream so a tight print loop cannot flood the SSE channel. Much
+# higher than the model-visible result cap (tools._MAX_OUTPUT_CHARS) since the
+# UI keeps the live stream as the displayed output when the result is truncated.
+TOOL_OUTPUT_STREAM_MAX_CHARS = 400_000
+
+_STREAM_CAPPED_NOTICE = "\n... (further live output not streamed)\n"
+
+
+def _drain_queue(q: "queue.Queue", sentinel: object, max_chars: int | None) -> tuple[str, bool]:
+    """Pull every currently-queued item, joining chunks in FIFO order.
+
+    With ``max_chars`` set, stop concatenating at the budget and discard the
+    remaining chunks in place, bounding peak allocation when a chatty tool queues
+    far more than the cap before the consumer wakes. The crossing chunk is sliced
+    to one char past the budget, enough for the caller's truncation to stay
+    byte-identical. Returns ``(joined_text, hit_sentinel)``; the surplus is still
+    scanned so completion is detected promptly.
+    """
+    parts: list[str] = []
+    total = 0
+    dropping = False
+    hit_sentinel = False
+    while True:
+        try:
+            item = q.get_nowait()
+        except queue.Empty:
+            break
+        if item is sentinel:
+            hit_sentinel = True
+            break
+        if dropping:
+            continue
+        if max_chars is not None and total + len(item) > max_chars:
+            # Keep one char past the budget as the overflow signal; drop the rest.
+            parts.append(item[: max(0, max_chars - total) + 1])
+            dropping = True
+            continue
+        parts.append(item)
+        total += len(item)
+    return "".join(parts), hit_sentinel
+
+
+def stream_tool_execution(
+    invoke: Callable[[Callable[[str], None]], str],
+    *,
+    tool_name: str,
+    tool_call_id: str = "",
+    cancel_event: Any = None,
+    heartbeat_interval_s: float = TOOL_HEARTBEAT_INTERVAL_S,
+    poll_interval_s: float = _POLL_INTERVAL_S,
+) -> Generator[dict, None, str]:
+    """Run ``invoke(output_callback)`` in a thread; yield live events; return the result.
+
+    ``invoke`` receives a thread-safe ``callable(str)`` it may call with
+    incremental output chunks (or ignore entirely). Exceptions raised by the
+    tool propagate to the caller unchanged after the worker thread finishes.
+
+    ``cancel_event`` is the request-level cancellation signal already handed to
+    the tool. If the consumer closes this generator early (an SSE disconnect
+    calls ``gen.close()``, raising ``GeneratorExit`` at a ``yield``), the wrapper
+    sets it so a cancel-observing tool stops, then joins the worker with a bounded
+    timeout. Set ONLY on that abnormal-exit path, never on a clean finish, because
+    the event is shared across a turn's tool calls and setting it early would
+    abort the next tool.
+    """
+    output_queue: queue.Queue[Any] = queue.Queue()
+    done_sentinel = object()
+    outcome: dict[str, Any] = {}
+
+    # Bound accepted output at the PRODUCER boundary: the consumer-side cap alone
+    # wouldn't stop a fast worker enqueuing unboundedly while a slow SSE client
+    # backpressures. Accept at most one char past the cap (so the consumer still
+    # emits the capped notice) and drop the rest. The final result is captured
+    # independently, so this never changes the byte-identical result.
+    accepted_output_chars = 0
+    accepted_output_lock = threading.Lock()
+
+    def _on_output(text: str) -> None:
+        nonlocal accepted_output_chars
+        if not text:
+            return
+        with accepted_output_lock:
+            remaining = TOOL_OUTPUT_STREAM_MAX_CHARS + 1 - accepted_output_chars
+            if remaining <= 0:
+                return
+            accepted = text[:remaining]
+            accepted_output_chars += len(accepted)
+        output_queue.put(accepted)
+
+    def _run() -> None:
+        try:
+            outcome["result"] = invoke(_on_output)
+        except BaseException as exc:  # noqa: BLE001 - re-raised on the caller side
+            outcome["error"] = exc
+        finally:
+            # Posted after the result/error is recorded; wakes the consumer
+            # immediately so fast tools pay no poll-interval latency.
+            output_queue.put(done_sentinel)
+
+    worker = threading.Thread(
+        target = _run,
+        daemon = True,
+        name = f"tool-exec-{tool_name or 'unknown'}",
+    )
+    worker.start()
+
+    # Heartbeats are paced by counting idle queue polls rather than a wall clock
+    # (tests patch ``time.monotonic`` globally, so the wrapper must not read it).
+    idle_polls_per_heartbeat = max(1, int(round(heartbeat_interval_s / poll_interval_s)))
+    idle_polls = 0
+    streamed_chars = 0
+    stream_capped = False
+    finished = False
+
+    def _drain_pending(max_chars: int | None = None) -> str:
+        nonlocal finished
+        text, hit_sentinel = _drain_queue(output_queue, done_sentinel, max_chars)
+        if hit_sentinel:
+            finished = True
+        return text
+
+    def _drain_and_drop() -> None:
+        """Discard the current and every queued chunk without concatenating.
+
+        Past the cap every chunk is dropped, so don't pay to build a combined
+        string only to drop it. Still detect completion so the loop can exit.
+        """
+        nonlocal finished
+        while True:
+            try:
+                item = output_queue.get_nowait()
+            except queue.Empty:
+                return
+            if item is done_sentinel:
+                finished = True
+                return
+
+    abnormal_exit = False
+    try:
+        while not finished:
+            try:
+                item = output_queue.get(timeout = poll_interval_s)
+            except queue.Empty:
+                # A disconnect sets cancel_event while the worker is silent;
+                # surface a heartbeat this poll so the route regains control and
+                # tears down at once, not after a full heartbeat interval.
+                if cancel_event is not None and cancel_event.is_set():
+                    yield {"type": "heartbeat"}
+                    continue
+                idle_polls += 1
+                if idle_polls >= idle_polls_per_heartbeat:
+                    idle_polls = 0
+                    yield {"type": "heartbeat"}
+                continue
+
+            if item is done_sentinel:
+                break
+
+            if stream_capped:
+                # Past the cap: drop this chunk and every queued sibling (see
+                # _drain_and_drop). Pace with one time.sleep per poll (not
+                # time.monotonic -- tests patch the clock), counted as an idle
+                # poll so heartbeats keep flowing while the queue stays non-empty.
+                _drain_and_drop()
+                if finished:
+                    break
+                time.sleep(poll_interval_s)
+                idle_polls += 1
+                if idle_polls >= idle_polls_per_heartbeat:
+                    idle_polls = 0
+                    yield {"type": "heartbeat"}
+                continue
+
+            # Bound the join to the remaining budget so the crossing batch can't
+            # allocate far past the cap (surplus is truncated below anyway); the
+            # prefix is long enough that truncation stays byte-identical.
+            budget = TOOL_OUTPUT_STREAM_MAX_CHARS - streamed_chars
+            chunk = item + _drain_pending(max_chars = budget - len(item))
+            idle_polls = 0
+            if streamed_chars + len(chunk) > TOOL_OUTPUT_STREAM_MAX_CHARS:
+                chunk = chunk[: max(0, TOOL_OUTPUT_STREAM_MAX_CHARS - streamed_chars)]
+                chunk += _STREAM_CAPPED_NOTICE
+                stream_capped = True
+            streamed_chars += len(chunk)
+            if chunk:
+                yield {
+                    "type": "tool_output",
+                    "tool_name": tool_name,
+                    "tool_call_id": tool_call_id,
+                    "text": chunk,
+                }
+    except BaseException:
+        # The loop only raises when the consumer closes us early: an SSE
+        # disconnect calls gen.close() (GeneratorExit at the yield) or the route
+        # throws in. Signal cancellation so a cancel-observing tool returns; the
+        # daemon worker is then abandoned (see finally). Re-raise so the caller
+        # sees the real cause (GeneratorExit must not be swallowed). Runs ONLY on
+        # abnormal exit, so the shared cancel_event is never set out from under
+        # the next tool in a clean multi-tool turn.
+        abnormal_exit = True
+        if cancel_event is not None:
+            try:
+                cancel_event.set()
+            except Exception:
+                pass
+        raise
+    finally:
+        # Clean finish: the worker already recorded its result and queued the
+        # sentinel we consumed, so this join returns at once. Abnormal exit:
+        # cancel_event is set and the daemon worker abandoned, so join with a zero
+        # timeout -- teardown never blocks the caller (the route may close this
+        # generator on the event loop), and the daemon cannot outlive the process.
+        worker.join(timeout = 0 if abnormal_exit else _WORKER_JOIN_TIMEOUT_S)
+
+    error = outcome.get("error")
+    if error is not None:
+        raise error
+    # Returned verbatim (the loop's record_result handles non-str), so the
+    # final tool result is byte-identical to a direct execute_tool call.
+    return outcome.get("result")
diff --git a/studio/backend/core/inference/tools.py b/studio/backend/core/inference/tools.py
index 84a67c6ad4..3f9d341749 100644
--- a/studio/backend/core/inference/tools.py
+++ b/studio/backend/core/inference/tools.py
@@ -13,6 +13,7 @@ import signal
 os.environ["UNSLOTH_IS_PRESENT"] = "1"
 
 import asyncio
+import queue
 import random
 import re
 import shlex
@@ -21,6 +22,7 @@ import subprocess
 import sys
 import tempfile
 import threading
+import time
 import urllib.parse
 import urllib.request
 
@@ -73,7 +75,21 @@ if sys.platform != "win32":
 # Raster-image allowlist for sandbox file serving.
 # No .svg (XSS via embedded scripts), no .html, no .pdf.
 _IMAGE_EXTS = frozenset({".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"})
-_MAX_OUTPUT_CHARS = 8000  # truncate long output
+
+
+def _env_int(name: str, default: int) -> int:
+    """Read an int env override; fall back to ``default`` on unset/garbage."""
+    try:
+        value = int(os.environ.get(name, "") or default)
+    except (TypeError, ValueError):
+        return default
+    return value if value > 0 else default
+
+
+# Model-visible cap on python/terminal tool results (protects the context
+# window). The live UI stream is capped separately and higher, so _truncate's
+# notice stays mode-neutral (see tool_stream_exec.TOOL_OUTPUT_STREAM_MAX_CHARS).
+_MAX_OUTPUT_CHARS = _env_int("UNSLOTH_TOOL_RESULT_MAX_CHARS", 16000)
 _BLOCKED_COMMANDS_COMMON = frozenset(
     {
         "rm",
@@ -204,8 +220,7 @@ def _find_blocked_commands(command: str) -> set[str]:
     blocked: set[str] = set()
 
     # punctuation_chars splits separators into their own tokens, so command
-    # position is detected even in `echo done; rm -rf x` (no whitespace) or
-    # quote-split names (`r''m` collapses to `rm` after `;`).
+    # position is detected even in `echo done; rm -rf x` (no whitespace).
     try:
         if sys.platform == "win32":
             tokens = shlex.split(command, posix = False)
@@ -309,6 +324,9 @@ def _find_blocked_commands(command: str) -> set[str]:
     return blocked
 
 
+# Directory holding the sandbox ``sitecustomize.py`` shim (code-interpreter
+# path remap); placed on the sandboxed child's PYTHONPATH in _build_safe_env.
+_SANDBOX_SITE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sandbox_site")
 # ── "Approve for me" (permission_mode="auto") safety detection ──────────────
 # Auto mode pauses only calls classified here as potentially unsafe. The sandbox
 # and hard blocks (blocklist, rlimits) still apply at run time; this gate only
@@ -2476,9 +2494,11 @@ def _build_safe_env(workdir: str) -> dict[str, str]:
     """Build a minimal, credential-free environment for sandboxed subprocesses.
 
     Whitelist-built from scratch (parent env NOT inherited): only PATH/HOME/
-    TMPDIR/LANG/TERM/PYTHONIOENCODING (+VIRTUAL_ENV or Windows SystemRoot) reach
-    the child; all credential vars (HF_TOKEN, AWS_*, etc.) are absent. HOME
-    points at the sandbox workdir so SDKs can't read the operator's cached creds.
+    TMPDIR/LANG/TERM/PYTHONIOENCODING/PYTHONPATH (+VIRTUAL_ENV or Windows
+    SystemRoot) reach the child; all credential vars (HF_TOKEN, AWS_*, etc.)
+    are absent. HOME points at the sandbox workdir so SDKs can't read the
+    operator's cached creds. PYTHONPATH carries only the sandbox sitecustomize
+    shim directory.
     """
     # Start from the running interpreter's dir so 'python'/'pip' resolve to the
     # same environment the Studio server runs in.
@@ -2508,6 +2528,9 @@ def _build_safe_env(workdir: str) -> dict[str, str]:
         "LANG": os.environ.get("LANG", "C.UTF-8"),
         "TERM": "dumb",
         "PYTHONIOENCODING": "utf-8",
+        # sitecustomize shim: remaps ChatGPT code-interpreter paths (/mnt/data
+        # etc.) onto the sandbox CWD; see sandbox_site/sitecustomize.py.
+        "PYTHONPATH": _SANDBOX_SITE_DIR,
     }
     if venv:
         env["VIRTUAL_ENV"] = venv
@@ -2542,13 +2565,10 @@ _BYPASS_ENV_SECRET_NAMES = frozenset(
         "KAGGLE_KEY",
         "MYSQL_PWD",  # exact name: markers use PASSWD, not PWD (PWD is the cwd var)
         "LD_PRELOAD",
-        # Auth brokers / capability handles: not secrets by value, but they
-        # hand the child the operator's live agent (ssh/gpg), kube config, or
-        # docker daemon. Names are listed because there is no value signal to
-        # key off. URL config vars (HTTP_PROXY, PIP_INDEX_URL, DATABASE_URL,
-        # ...) are intentionally NOT name-listed: a benign proxy/index without
-        # credentials must keep working in bypass mode, while a credentialed
-        # value is dropped by _is_secret_env_value() regardless of its name.
+        # Auth brokers / capability handles: hand the child the operator's live
+        # agent (ssh/gpg), kube config, or docker daemon. Listed by name (no
+        # value signal). URL config vars are NOT name-listed: a credentialed
+        # value is dropped by _is_secret_env_value() regardless of name.
         "SSH_AUTH_SOCK",
         "SSH_AGENT_PID",
         "GPG_AGENT_INFO",
@@ -2568,37 +2588,30 @@ _BYPASS_ENV_SECRET_MARKERS = (
     "CREDENTIAL",
     "PRIVATE_KEY",
     "AUTH",  # e.g. NPM_CONFIG__AUTH (npm _auth), REDISCLI_AUTH
-    # Azure App Service connection strings: SQLCONNSTR_/CUSTOMCONNSTR_/... and
-    # WEBSITE_CONTENTAZUREFILECONNECTIONSTRING carry DB/storage credentials.
+    # Azure App Service connection strings carry DB/storage credentials.
     "CONNSTR",
     "CONNECTIONSTRING",
 )
 # Non-secret hardening flags that match a secret prefix/marker but must be KEPT
-# so bypass mode does not silently undo an operator's opt-out. AWS_EC2_METADATA_
-# DISABLED tells the AWS SDK/CLI not to pull instance-role creds from IMDS;
-# dropping it would re-open that path for a bypassed tool.
+# so bypass mode does not undo an operator's opt-out (e.g.
+# AWS_EC2_METADATA_DISABLED blocks the AWS SDK from pulling IMDS creds).
 _BYPASS_ENV_KEEP_NAMES = frozenset(
     {
         "AWS_EC2_METADATA_DISABLED",
         "AWS_EC2_METADATA_V1_DISABLED",
     }
 )
-# Matches a URL that embeds userinfo before the host, covering both
-# "scheme://user:pass@host" and token-only "scheme://token@host" (and
-# percent-encoded variants). The userinfo must precede the first '/', so an '@'
-# in a path or query does not false-positive. Used to scrub credential-bearing
-# URL values regardless of the variable's name.
+# Matches a URL embedding userinfo before the host ("scheme://user:pass@host"
+# and token-only forms). The userinfo must precede the first '/', so an '@' in
+# a path/query does not false-positive.
 _URL_USERINFO_RE = re.compile(r"://[^/\s@]+@")
-# Connection-string credential fields (ADO.NET / Azure storage / Service Bus):
-# "...;Password=...", "...;AccountKey=...", "...;SharedAccessKey=...". Catches
-# credential-bearing values whose names dodge the name classifier. "accesskey"
-# also covers Shared/Secret AccessKey via substring; the Name fields (e.g.
-# SharedAccessKeyName=) do not match since "=" must follow the keyword.
+# Connection-string credential fields (ADO.NET / Azure storage / Service Bus)
+# whose names dodge the name classifier. The Name fields (SharedAccessKeyName=)
+# don't match since "=" must follow the keyword.
 _SECRET_VALUE_RE = re.compile(r"(?i)(?:password|pwd|accountkey|accesskey)\s*=\s*[^\s;]")
 
-# Names that hold no secret value but point SDKs at the operator's real
+# Names holding no secret value but pointing SDKs at the operator's real
 # home/cache/config (cached tokens, cred files), defeating the HOME repoint.
-# Startup always sets HF_HOME (-> $HF_HOME/token), so this is the live leak.
 # Dropped in bypass mode so tools fall back to the empty repointed HOME.
 _BYPASS_ENV_CRED_LOCATION_NAMES = frozenset(
     {
@@ -2679,12 +2692,12 @@ def _is_secret_env_value(value: str) -> bool:
 
 
 def _build_bypass_env(workdir: str) -> dict[str, str]:
-    """Env for bypass exec: full host env (unrestricted) minus credential vars,
-    with HOME/TMPDIR repointed at the workdir so SDKs cannot read cached creds.
+    """Env for bypass exec: full host env minus credential vars, with HOME/TMPDIR
+    repointed at the workdir so SDKs cannot read cached creds.
 
-    Note: stripping the child env is necessary but not sufficient on its own -
-    a same-UID child can still read the parent's environment via procfs, so
-    callers also harden the parent (see _harden_parent_against_proc_env_leak).
+    Stripping the child env is necessary but not sufficient (a same-UID child can
+    read the parent's env via procfs), so callers also harden the parent (see
+    _harden_parent_against_proc_env_leak).
     """
     env = {
         k: v
@@ -2699,6 +2712,12 @@ def _build_bypass_env(workdir: str) -> dict[str, str]:
     # the bypassed tool writes under the per-session sandbox dir on every OS.
     env["TEMP"] = workdir
     env["TMP"] = workdir
+    # sitecustomize path shim (see _build_safe_env). Bypass inherits the
+    # operator's PYTHONPATH, so prepend rather than replace.
+    inherited_pythonpath = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = os.pathsep.join(
+        part for part in (_SANDBOX_SITE_DIR, inherited_pythonpath) if part
+    )
     # Windows SDKs read creds under the profile dirs, not $HOME; repoint set
     # ones to the workdir (HOMEDRIVE/HOMEPATH are dropped above).
     for var in _BYPASS_ENV_WINDOWS_PROFILE_VARS:
@@ -2789,24 +2808,14 @@ def _harden_parent_against_proc_env_leak() -> bool:
     """Make the Studio process's /proc/<pid>/environ unreadable to its children.
 
     Stripping the child env is not enough on Linux: a bypassed same-UID child
-    runs unsandboxed and can read /proc/<getppid()>/environ to recover the
-    tool-executing process's *unfiltered* secrets (HF_TOKEN, cloud keys, ...).
-    Clearing the dumpable flag (PR_SET_DUMPABLE=0) reparents this process's
-    /proc entries to root, so a same-UID child can no longer read its environ.
+    can read /proc/<getppid()>/environ to recover the parent's unfiltered
+    secrets. Clearing PR_SET_DUMPABLE reparents this process's /proc entries to
+    root, closing that read.
 
-    Returns True when the process is hardened or hardening is unnecessary (no
-    /proc leak off Linux), and False when it is needed but could not be applied
-    (e.g. prctl denied by a seccomp policy). Callers must fail closed - refuse
-    the unsandboxed exec - when this returns False, rather than running with the
-    parent environ still readable.
-
-    Scope: this closes the direct parent read (the demonstrated leak). It is a
-    mitigation, not a full boundary - a bypassed tool is unsandboxed by design,
-    so it can still walk /proc to a same-UID *ancestor* (e.g. the launching
-    shell) or read on-disk credentials by absolute path. Complete isolation
-    needs a separate uid / PID+mount namespace, which is out of scope here; the
-    UI already warns the mode is dangerous. Applied lazily on first bypass exec
-    so non-bypass operation is unchanged.
+    Returns True when hardened or unnecessary (off Linux), False when needed but
+    unappliable (e.g. prctl denied by seccomp); callers must then fail closed.
+    This is a mitigation, not a full boundary - a bypassed tool can still walk
+    /proc to an ancestor or read creds by path. Applied lazily on first bypass.
     """
     global _parent_proc_hardened
     if _parent_proc_hardened:
@@ -2933,11 +2942,20 @@ WEB_SEARCH_TOOL = {
     },
 }
 
+# Appended to the python/terminal descriptions: models habitually write to
+# /mnt/data (a ChatGPT code-interpreter path), which does not exist here.
+_SANDBOX_PATHS_NOTE = (
+    " Read and write files using relative paths in the current working "
+    "directory, which persists for this conversation; absolute paths like "
+    "/mnt/data or /tmp/outputs do not exist."
+)
+
 PYTHON_TOOL = {
     "type": "function",
     "function": {
         "name": "python",
-        "description": "Execute Python code in a sandbox and return stdout/stderr.",
+        "description": "Execute Python code in a sandbox and return stdout/stderr."
+        + _SANDBOX_PATHS_NOTE,
         "parameters": {
             "type": "object",
             "properties": {
@@ -2955,7 +2973,7 @@ TERMINAL_TOOL = {
     "type": "function",
     "function": {
         "name": "terminal",
-        "description": "Execute a terminal command and return stdout/stderr.",
+        "description": "Execute a terminal command and return stdout/stderr." + _SANDBOX_PATHS_NOTE,
         "parameters": {
             "type": "object",
             "properties": {
@@ -3034,9 +3052,8 @@ ALL_TOOLS = [
 ]
 
 
-# OpenAI's function.name regex ^[a-zA-Z0-9_-]{1,64}$, enforced before streaming.
-# MCP tool names with '.', '/', spaces, etc. would 400 the whole request, so we
-# validate up front and skip with a warning.
+# OpenAI's function.name regex; MCP names that violate it would 400 the whole
+# request, so validate up front and skip with a warning.
 _OPENAI_FN_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")
 
 
@@ -3082,8 +3099,7 @@ def _mcp_specs_for_server(server: dict, mcp_tools: list[dict]) -> list[dict]:
 
 async def get_enabled_mcp_tools() -> list[dict]:
     servers = [s for s in mcp_servers_db.list_servers() if s.get("is_enabled")]
-    # Never spawn stdio servers when stdio is disabled on this host (e.g. a DB
-    # carried from a desktop install onto a Colab/network deployment).
+    # Never spawn stdio servers when stdio is disabled on this host.
     if not stdio_mcp_enabled():
         servers = [s for s in servers if not is_stdio(s["url"])]
     if not servers:
@@ -3108,15 +3124,11 @@ async def get_enabled_mcp_tools() -> list[dict]:
             ),
             return_exceptions = True,
         )
-        # An edit/delete can land while we await a probe (up to 305 s for
-        # OAuth); its cache eviction is a no-op against an entry we haven't
-        # written yet. Re-read and drop a result whose server changed or
-        # was removed mid-probe, else a stale tool list caches indefinitely.
+        # An edit/delete can land while we await a probe; re-read and drop a
+        # result whose server changed or was removed mid-probe, else a stale
+        # tool list (or cool-off on a just-fixed server) persists.
         current = {s["id"]: s for s in mcp_servers_db.list_servers()}
         for server, payload in zip(uncached, results):
-            # Guard the failure branch too: a stale failure must not park a
-            # cool-off on the fresh config, or the server the user just fixed
-            # is skipped for the whole window.
             fresh = current.get(server["id"])
             if fresh is None or any(
                 fresh.get(k) != server.get(k) for k in TOOL_CACHE_INVALIDATING_FIELDS
@@ -3175,6 +3187,7 @@ def execute_tool(
     thread_id: str | None = None,
     rag_scope: dict | None = None,
     disable_sandbox: bool = False,
+    output_callback = None,
 ) -> str:
     """Execute a tool by name with the given arguments; returns a string.
 
@@ -3187,6 +3200,10 @@ def execute_tool(
     ``disable_sandbox``: Bypass Permissions; run python/terminal without the
     safety checks, blocklist, or resource caps (secrets still stripped). Only
     affects local code tools; web_search / MCP are unchanged.
+    ``output_callback``: optional ``callable(str)`` invoked with incremental
+    stdout/stderr chunks while python/terminal executions run (UI live
+    output). Purely observational: the returned result string is identical
+    with or without it. Tools without incremental output ignore it.
     """
     logger.info(f"execute_tool: name={name}, session_id={session_id}, timeout={timeout}")
     effective_timeout = _EXEC_TIMEOUT if timeout is _TIMEOUT_UNSET else timeout
@@ -3247,6 +3264,7 @@ def execute_tool(
             arguments.get("query", ""),
             url = arguments.get("url"),
             timeout = effective_timeout,
+            cancel_event = cancel_event,
         )
     if name == "python":
         return _python_exec(
@@ -3255,6 +3273,7 @@ def execute_tool(
             effective_timeout,
             session_id,
             disable_sandbox = disable_sandbox,
+            output_callback = output_callback,
         )
     if name == "terminal":
         return _bash_exec(
@@ -3263,6 +3282,7 @@ def execute_tool(
             effective_timeout,
             session_id,
             disable_sandbox = disable_sandbox,
+            output_callback = output_callback,
         )
     return f"Unknown tool: {name}"
 
@@ -3468,11 +3488,10 @@ def build_rag_autoinject(conversation: list[dict], rag_scope: dict | None) -> di
     sidebar_k = _opt_int(rag_scope.get("default_top_k"))
     top_k = min(sidebar_k, lean_k) if sidebar_k is not None else lean_k
 
-    # Whole-document mode: a thread-attached file under budget is injected in full so
-    # the model reads everything. A KB selection is exclusive, so whole-doc never
-    # preempts it; in a project chat the project sources are still retrieved top-K and
-    # appended under one citation numbering. Oversized files (or no thread doc) fall
-    # through to the combined top-K retrieval below.
+    # Whole-document mode: a thread-attached file under budget is injected in
+    # full. A KB selection is exclusive so whole-doc never preempts it; project
+    # sources are still retrieved top-K and appended under one citation
+    # numbering. Oversized/absent thread docs fall through to top-K below.
     if whole_doc_requested:
         try:
             budget = _whole_doc_budget(rag_scope, conversation)
@@ -3577,9 +3596,8 @@ def build_rag_autoinject(conversation: list[dict], rag_scope: dict | None) -> di
 
 
 _MAX_PAGE_CHARS = 16000  # cap fetched page text (after HTML-to-MD conversion)
-# Raw download cap > _MAX_PAGE_CHARS because SSR pages embed large <head>
-# sections stripped during conversion; 512 KB reaches article content even
-# where <head> alone is ~200 KB.
+# Raw download cap > _MAX_PAGE_CHARS since SSR pages embed large <head> sections
+# stripped during conversion; 512 KB still reaches article content.
 _MAX_FETCH_BYTES = 512 * 1024
 
 _USER_AGENTS = (
@@ -3662,10 +3680,8 @@ def _validate_and_resolve_host(hostname: str, port: int) -> tuple[bool, str, str
 
     for *_, sockaddr in infos:
         ip = ipaddress.ip_address(sockaddr[0])
-        # `not ip.is_global` is the source of truth: it rejects every category
-        # below PLUS shared/CGNAT (100.64.0.0/10) and benchmarking/doc ranges
-        # Python marks is_private=False and is_global=False. The explicit
-        # predicates only give human-readable categories in the error message.
+        # `not ip.is_global` is the source of truth (also rejects CGNAT and
+        # benchmarking/doc ranges); the explicit predicates only label the error.
         if (
             not ip.is_global
             or ip.is_private
@@ -3682,28 +3698,208 @@ def _validate_and_resolve_host(hostname: str, port: int) -> tuple[bool, str, str
     return True, "", first_ip
 
 
-def _fetch_page_text(
-    url: str,
-    max_chars: int = _MAX_PAGE_CHARS,
-    timeout: int = 30,
-) -> str:
-    """Fetch a URL and return plain text content (HTML tags stripped).
+# First path segments on github.com that are site pages, not repo owners.
+_GITHUB_NON_OWNER_SEGMENTS = frozenset(
+    {
+        "about",
+        "apps",
+        "codespaces",
+        "collections",
+        "contact",
+        "customer-stories",
+        "dashboard",
+        "discussions",
+        "enterprise",
+        "explore",
+        "features",
+        "issues",
+        "join",
+        "login",
+        "marketplace",
+        "new",
+        "notifications",
+        "organizations",
+        "orgs",
+        "pricing",
+        "pulls",
+        "search",
+        "security",
+        "settings",
+        "signup",
+        "site",
+        "sponsors",
+        "team",
+        "topics",
+        "trending",
+    }
+)
+_GITHUB_NAME_RE = re.compile(r"\A[A-Za-z0-9_.\-]{1,100}\Z")
 
-    Blocks private/loopback/link-local targets (SSRF protection) and caps
-    the download size to avoid unbounded memory usage.
+
+def _github_repo_readme_api_url(url: str) -> str | None:
+    """README API URL for a ``github.com/{owner}/{repo}`` page, else None.
+
+    A repo root page rendered as HTML is mostly UI chrome (nav, file table,
+    stats); the ``/readme`` API returns the raw README markdown unauthenticated,
+    which is what the model actually wants to read.
+    """
+    from urllib.parse import urlparse
+
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").lower()
+    if host not in ("github.com", "www.github.com"):
+        return None
+    parts = [p for p in parsed.path.split("/") if p]
+    if len(parts) != 2:
+        return None
+    owner, repo = parts
+    if owner.lower() in _GITHUB_NON_OWNER_SEGMENTS:
+        return None
+    if repo.endswith(".git"):
+        repo = repo[: -len(".git")]
+    if not (_GITHUB_NAME_RE.match(owner) and _GITHUB_NAME_RE.match(repo)):
+        return None
+    return f"https://api.github.com/repos/{owner}/{repo}/readme"
+
+
+# A single fetch can chain several steps (README API attempt, HTML fallback, up
+# to five redirect hops, each reading a body). A per-operation socket timeout
+# bounds one stalled step but not their sum, and nothing aborts on client
+# disconnect, so one overall wall-clock deadline (plus a cooperative
+# cancel_event) bounds the whole fetch instead.
+def _fetch_budget_exceeded(deadline, cancel_event):
+    """User-facing error string when the fetch must stop early, else None."""
+    if cancel_event is not None and cancel_event.is_set():
+        return "Failed to fetch URL: cancelled."
+    if deadline is not None and time.monotonic() >= deadline:
+        return "Failed to fetch URL: timed out."
+    return None
+
+
+def _fetch_hop_timeout(timeout, deadline):
+    """Per-operation socket timeout: the lesser of the caller's per-op timeout
+    and the time left on the deadline, so one slow hop cannot overrun the whole
+    budget. Callers check ``_fetch_budget_exceeded`` first, so remaining time is
+    positive here; the tiny floor only guards a race."""
+    if deadline is None:
+        return timeout
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        remaining = 0.001
+    return remaining if timeout is None else min(timeout, remaining)
+
+
+def _resolve_with_budget(hostname, port, deadline, cancel_event):
+    """``_validate_and_resolve_host`` bounded by the overall fetch budget.
+
+    ``getaddrinfo`` is blocking with no deadline of its own, so a slow resolver
+    (or a request cancelled before dispatch) could run past the budget. Resolve
+    on a daemon thread and poll the budget so the fetch aborts on time; the
+    abandoned lookup is discarded. With no deadline and no cancel_event this is a
+    plain synchronous call, so opt-out callers keep the old behavior and cost.
+    """
+    budget_error = _fetch_budget_exceeded(deadline, cancel_event)
+    if budget_error is not None:
+        return False, budget_error, ""
+    if deadline is None and cancel_event is None:
+        return _validate_and_resolve_host(hostname, port)
+
+    result: "queue.Queue" = queue.Queue(maxsize = 1)
+
+    def _resolve():
+        try:
+            result.put(_validate_and_resolve_host(hostname, port))
+        except Exception as exc:  # defensive: never let the worker die silently
+            result.put((False, f"Failed to resolve host: {exc}", ""))
+
+    threading.Thread(target = _resolve, name = "web-fetch-dns", daemon = True).start()
+    while True:
+        budget_error = _fetch_budget_exceeded(deadline, cancel_event)
+        if budget_error is not None:
+            return False, budget_error, ""
+        try:
+            return result.get(timeout = 0.05)
+        except queue.Empty:
+            continue
+
+
+def _read_capped_body(resp, max_bytes, timeout, deadline, cancel_event):
+    """Read up to ``max_bytes``, enforcing the overall budget between chunks.
+
+    A single ``resp.read(max_bytes)`` can block for the whole transfer if the
+    server dribbles bytes just inside each socket-inactivity timeout, so the body
+    is read in chunks with the budget re-checked (and the socket timeout
+    re-tightened toward the deadline) each round. The joined bytes are identical
+    to one capped read. Returns ``(error_or_None, body_bytes)``.
+    """
+    # Best-effort handle on the underlying socket so its timeout tightens as the
+    # deadline nears; absent on test doubles, where the between-chunk budget
+    # check still bounds the read.
+    sock = getattr(getattr(getattr(resp, "fp", None), "raw", None), "_sock", None)
+    chunks = []
+    remaining = max_bytes
+    while remaining > 0:
+        budget_error = _fetch_budget_exceeded(deadline, cancel_event)
+        if budget_error is not None:
+            try:
+                resp.close()
+            except Exception:
+                pass
+            return budget_error, b""
+        if sock is not None:
+            try:
+                sock.settimeout(_fetch_hop_timeout(timeout, deadline))
+            except Exception:
+                pass
+        chunk = resp.read(min(65536, remaining))
+        if not chunk:
+            break
+        chunks.append(chunk)
+        remaining -= len(chunk)
+    budget_error = _fetch_budget_exceeded(deadline, cancel_event)
+    if budget_error is not None:
+        try:
+            resp.close()
+        except Exception:
+            pass
+        return budget_error, b""
+    return None, b"".join(chunks)
+
+
+def _fetch_url_raw(
+    url: str,
+    timeout: int = 30,
+    extra_headers: dict | None = None,
+    deadline: float | None = None,
+    cancel_event = None,
+) -> tuple[str | None, str, str]:
+    """Fetch a URL with SSRF protection; return ``(error, body_text, content_type)``.
+
+    ``error`` is a user-facing message string when the fetch failed (the
+    existing "Blocked:" / "Failed to fetch URL:" wording), else ``None``.
+    Blocks private/loopback/link-local targets and caps the download size.
+
+    ``deadline`` is an optional ``time.monotonic`` cutoff for the whole fetch
+    (redirect hops and body read included) and ``cancel_event`` aborts it when
+    the caller goes away; both default off so callers keep the old behavior.
     """
     from urllib.parse import urlparse
 
     parsed = urlparse(url)
     if parsed.scheme not in ("http", "https"):
-        return f"Blocked: only http/https URLs are allowed (got {parsed.scheme!r})."
+        return f"Blocked: only http/https URLs are allowed (got {parsed.scheme!r}).", "", ""
     if not parsed.hostname:
-        return "Blocked: URL is missing a hostname."
+        return "Blocked: URL is missing a hostname.", "", ""
 
     port = parsed.port or (443 if parsed.scheme == "https" else 80)
-    ok, reason, pinned_ip = _validate_and_resolve_host(parsed.hostname, port)
+    ok, reason, pinned_ip = _resolve_with_budget(
+        parsed.hostname,
+        port,
+        deadline,
+        cancel_event,
+    )
     if not ok:
-        return reason
+        return reason, "", ""
 
     try:
         from urllib.error import HTTPError as _HTTPError
@@ -3715,6 +3911,9 @@ def _fetch_page_text(
         ua = random.choice(_USER_AGENTS)
 
         for _hop in range(5):
+            budget_error = _fetch_budget_exceeded(deadline, cancel_event)
+            if budget_error is not None:
+                return budget_error, "", ""
             # Pin to the validated IP (prevents DNS rebinding): rewrite URL to
             # the IP, set the Host header.
             cp = urlparse(current_url)
@@ -3728,57 +3927,206 @@ def _fetch_page_text(
                 _SNIHTTPSHandler(current_host),
             )
 
-            req = urllib.request.Request(
-                pinned_url,
-                headers = {
-                    "User-Agent": ua,
-                    "Host": current_host,
-                },
-            )
+            headers = {
+                "User-Agent": ua,
+                "Host": current_host,
+            }
+            if extra_headers:
+                headers.update(extra_headers)
+            req = urllib.request.Request(pinned_url, headers = headers)
             try:
-                resp = opener.open(req, timeout = timeout)
+                # Cap the socket timeout at the time left on the overall deadline
+                # so a single slow hop cannot outlast the whole fetch budget.
+                resp = opener.open(req, timeout = _fetch_hop_timeout(timeout, deadline))
             except _HTTPError as e:
                 if e.code not in (301, 302, 303, 307, 308):
-                    return f"Failed to fetch URL: HTTP {e.code} {getattr(e, 'reason', '')}"
+                    return f"Failed to fetch URL: HTTP {e.code} {getattr(e, 'reason', '')}", "", ""
                 location = e.headers.get("Location")
                 if not location:
-                    return "Failed to fetch URL: redirect missing Location header."
+                    return "Failed to fetch URL: redirect missing Location header.", "", ""
                 current_url = urljoin(current_url, location)
                 rp = urlparse(current_url)
                 if rp.scheme not in ("http", "https") or not rp.hostname:
-                    return "Blocked: redirect target is not a valid http/https URL."
+                    return "Blocked: redirect target is not a valid http/https URL.", "", ""
                 rp_port = rp.port or (443 if rp.scheme == "https" else 80)
-                ok2, reason2, pinned_ip = _validate_and_resolve_host(
+                ok2, reason2, pinned_ip = _resolve_with_budget(
                     rp.hostname,
                     rp_port,
+                    deadline,
+                    cancel_event,
                 )
                 if not ok2:
-                    return reason2
+                    return reason2, "", ""
                 current_host = rp.hostname
                 continue
-            # Success: read capped body.
-            raw_bytes = resp.read(max_bytes)
+            # Success: read the capped body enforcing the budget between chunks
+            # (see _read_capped_body), so a slow-drip server can't stretch a
+            # single resp.read past the deadline.
+            body_error, raw_bytes = _read_capped_body(
+                resp,
+                max_bytes,
+                timeout,
+                deadline,
+                cancel_event,
+            )
+            if body_error is not None:
+                return body_error, "", ""
             break
         else:
-            return "Failed to fetch URL: too many redirects."
+            return "Failed to fetch URL: too many redirects.", "", ""
 
         charset = resp.headers.get_content_charset() or "utf-8"
-        raw_html = raw_bytes.decode(charset, errors = "replace")
+        # get_content_type() defaults to "text/plain" when the header is
+        # absent (RFC 2045); report "" instead so callers can tell a missing
+        # header apart from a server that really declared text/plain.
+        if resp.headers.get("Content-Type") is None:
+            content_type = ""
+        else:
+            content_type = (resp.headers.get_content_type() or "").lower()
+        return None, raw_bytes.decode(charset, errors = "replace"), content_type
     except _HTTPError as e:
-        return f"Failed to fetch URL: HTTP {e.code} {getattr(e, 'reason', '')}"
+        return f"Failed to fetch URL: HTTP {e.code} {getattr(e, 'reason', '')}", "", ""
     except Exception as e:
-        return f"Failed to fetch URL: {e}"
+        return f"Failed to fetch URL: {e}", "", ""
+
+
+# Tags that, at the very START of a body, mark it as HTML. Excludes ambiguous
+# tags (<div>/<p>/<span>/<a>/<img>/<h1>..<h6>/<table>) that legitimately open
+# centered-logo or badge-layout Markdown READMEs and must stay Markdown.
+_HTML_LEADING_TAGS = (
+    "html",
+    "head",
+    "body",
+    "title",
+    "meta",
+    "link",
+    "script",
+    "style",
+    "article",
+    "section",
+    "main",
+    "header",
+    "footer",
+    "nav",
+    "aside",
+    "figure",
+    "form",
+    "ul",
+    "ol",
+    "dl",
+    "pre",
+    "blockquote",
+)
+_HTML_LEADING_RE = re.compile(r"<(?:!doctype\s+html|/?(?:" + "|".join(_HTML_LEADING_TAGS) + r")\b)")
+
+
+def _looks_like_html(body: str) -> bool:
+    """True only when the document ITSELF opens with HTML.
+
+    Matches an HTML doctype or a leading document/structure tag after optional
+    whitespace, not a mere substring, so a Markdown README with a fenced HTML
+    example or tags further down stays Markdown. Also detects bare fragments
+    (``<body>``/``<article>``/...) with no doctype, so a page with a
+    missing/wrong Content-Type is still converted.
+    """
+    probe = body.lstrip()[:256].lower()
+    return bool(_HTML_LEADING_RE.match(probe))
+
+
+# Stricter than _HTML_LEADING_RE: only a real document opener (doctype or leading
+# <html>/<head>/<body>), never a block tag a Markdown file can open with. Used on
+# the raw GitHub README body so a Markdown README starting with an HTML block is
+# not run through html_to_markdown, which would collapse its headings, lists and
+# fenced code onto one line.
+_HTML_DOCUMENT_RE = re.compile(r"<(?:!doctype\s+html\b|/?(?:html|head|body)\b)")
+
+
+def _looks_like_html_document(body: str) -> bool:
+    """True only when the body opens as a full HTML document (e.g. a .html README)."""
+    probe = body.lstrip()[:256].lower()
+    return bool(_HTML_DOCUMENT_RE.match(probe))
+
+
+def _truncate_page_text(text: str, max_chars: int) -> str:
+    if not text:
+        return "(page returned no readable text)"
+    if len(text) > max_chars:
+        return text[:max_chars] + f"\n\n... (truncated, {len(text)} chars total)"
+    return text
+
+
+def _fetch_page_text(
+    url: str,
+    max_chars: int = _MAX_PAGE_CHARS,
+    timeout: int = 30,
+    cancel_event = None,
+) -> str:
+    """Fetch a URL and return readable text content.
+
+    HTML responses are converted to Markdown with a main-content heuristic
+    (``<article>``/``<main>`` scoping, hidden-element and boilerplate
+    stripping); non-HTML text responses are returned as-is. GitHub repo root
+    pages are rewritten to the README API so the model reads the README
+    instead of the repo page's UI chrome. Blocks private/loopback/link-local
+    targets (SSRF protection) and caps the download size.
+    """
+    # One wall-clock budget for the whole fetch. The README API attempt and its
+    # HTML fallback both draw from it, so a slow/failed API call cannot hand the
+    # fallback a fresh full timeout and double the worst case.
+    deadline = None if timeout is None else time.monotonic() + timeout
+    readme_api_url = _github_repo_readme_api_url(url)
+    if readme_api_url:
+        err, body, _ctype = _fetch_url_raw(
+            readme_api_url,
+            timeout = timeout,
+            extra_headers = {
+                "Accept": "application/vnd.github.raw+json",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+            deadline = deadline,
+            cancel_event = cancel_event,
+        )
+        # The README API is unauthenticated and rate-limited; on any failure fall
+        # back to the HTML page fetch. A 200 body is authoritative even when it is
+        # HTML (a .html README): convert it rather than falling back to the repo
+        # page's UI chrome, keeping the raw body if extraction yields nothing.
+        if err is None and body.strip():
+            readme_body = body
+            # The raw file is almost always Markdown. Only a real HTML document (a
+            # .html README) is converted; a Markdown README that merely opens with
+            # a block tag is kept as-is (see _HTML_DOCUMENT_RE).
+            if _looks_like_html_document(body):
+                from ._html_to_md import html_to_markdown
+                converted = html_to_markdown(body, main_content = True)
+                readme_body = converted if converted.strip() else body
+            if readme_body.strip():
+                return _truncate_page_text(
+                    f"README of {url} (fetched via the GitHub README API):\n\n" + readme_body,
+                    max_chars,
+                )
+
+    err, body, content_type = _fetch_url_raw(
+        url,
+        timeout = timeout,
+        deadline = deadline,
+        cancel_event = cancel_event,
+    )
+    if err is not None:
+        return err
+
+    # Trust a declared HTML type, and otherwise sniff the body: servers with a
+    # missing or wrong Content-Type (e.g. text/plain on an HTML page) still get
+    # converted, matching the pre-extraction behavior of always converting.
+    is_html = "html" in content_type or _looks_like_html(body)
+    if not is_html:
+        # Plain text / markdown / JSON (e.g. raw.githubusercontent.com):
+        # converting through the HTML renderer would collapse its whitespace.
+        return _truncate_page_text(body.strip(), max_chars)
 
     # Convert HTML to Markdown with the builtin converter (no external deps).
     from ._html_to_md import html_to_markdown
 
-    text = html_to_markdown(raw_html)
-
-    if not text:
-        return "(page returned no readable text)"
-    if len(text) > max_chars:
-        text = text[:max_chars] + f"\n\n... (truncated, {len(text)} chars total)"
-    return text
+    return _truncate_page_text(html_to_markdown(body, main_content = True), max_chars)
 
 
 def _web_search(
@@ -3786,6 +4134,7 @@ def _web_search(
     max_results: int = 5,
     timeout: int = _EXEC_TIMEOUT,
     url: str | None = None,
+    cancel_event = None,
 ) -> str:
     """Search the web using DuckDuckGo and return formatted results.
 
@@ -3794,14 +4143,25 @@ def _web_search(
     # Direct URL fetch mode.
     if url and url.strip():
         fetch_timeout = 60 if timeout is None else min(timeout, 60)
-        return _fetch_page_text(url.strip(), timeout = fetch_timeout)
+        return _fetch_page_text(
+            url.strip(),
+            timeout = fetch_timeout,
+            cancel_event = cancel_event,
+        )
 
     if not query or not query.strip():
         return "No query provided."
+    # A disconnect sets cancel_event; DDGS.text() is blocking and cannot be
+    # interrupted mid-flight, so gate on either side: skip an already-cancelled
+    # request, and discard results that land after the client has gone.
+    if cancel_event is not None and cancel_event.is_set():
+        return "Search cancelled."
     try:
         from ddgs import DDGS
 
         results = DDGS(timeout = timeout).text(query, max_results = max_results)
+        if cancel_event is not None and cancel_event.is_set():
+            return "Search cancelled."
         if not results:
             return "No results found."
         parts = []
@@ -4799,19 +5159,37 @@ def _check_code_safety(code: str) -> str | None:
     return None
 
 
+def _capture_process_group(proc):
+    """Return the setsid process-group id, or ``None`` when unavailable.
+
+    Captured right after ``Popen`` so a later ``poll()`` / ``wait()`` that reaps
+    the leader cannot make ``os.getpgid(proc.pid)`` fail first. POSIX-only:
+    Windows has no process groups (and no ``os.getpgid``), so return ``None``
+    there and let the single-pid ``proc.kill()`` fallback handle cleanup.
+    """
+    if os.name != "posix" or not hasattr(os, "getpgid"):
+        return None
+    try:
+        return os.getpgid(proc.pid)
+    except (AttributeError, ProcessLookupError, PermissionError, OSError):
+        return None
+
+
 def _kill_process_tree(proc) -> None:
     """SIGKILL the setsid process group; fall back to single-pid kill."""
     if proc.poll() is not None:
         return
-    try:
-        pgid = os.getpgid(proc.pid)
-    except (ProcessLookupError, PermissionError):
-        pgid = None
-    if pgid is not None:
+    pgid = None
+    if hasattr(os, "getpgid"):
+        try:
+            pgid = os.getpgid(proc.pid)
+        except (ProcessLookupError, PermissionError, OSError):
+            pgid = None
+    if pgid is not None and hasattr(os, "killpg"):
         try:
             os.killpg(pgid, signal.SIGKILL)
             return
-        except (ProcessLookupError, PermissionError):
+        except (ProcessLookupError, PermissionError, OSError):
             pass
     try:
         proc.kill()
@@ -4819,36 +5197,250 @@ def _kill_process_tree(proc) -> None:
         pass
 
 
+def _killpg_captured(pgid) -> None:
+    """SIGKILL a process group captured before its leader was waited on.
+
+    Once ``proc`` exits, ``os.getpgid(proc.pid)`` fails and ``_kill_process_tree``
+    short-circuits, so a stdout-holding grandchild that outlived the parent could
+    not otherwise be signaled. The pre-captured setsid group id still targets the
+    whole tree. No-op with no ``os.killpg`` (Windows) or nothing captured.
+    """
+    if pgid is None or not hasattr(os, "killpg"):
+        return
+    try:
+        os.killpg(pgid, signal.SIGKILL)
+    except (ProcessLookupError, PermissionError, OSError):
+        pass
+
+
 def _cancel_watcher(
     proc,
     cancel_event,
     poll_interval = 0.2,
+    pgid = None,
 ):
-    """Daemon thread that kills a process when cancel_event is set."""
+    """Daemon thread that kills a process when cancel_event is set.
+
+    ``pgid`` is the group id captured right after spawn; killing it directly
+    reaps a stdout-holding grandchild even when the watcher's own ``poll()``
+    already reaped the leader (which makes ``_kill_process_tree`` short-circuit).
+    """
     while proc.poll() is None:
         if cancel_event is not None and cancel_event.is_set():
+            _killpg_captured(pgid)
             _kill_process_tree(proc)
             return
         cancel_event.wait(poll_interval) if cancel_event else None
 
 
 def _truncate(text: str, limit: int = _MAX_OUTPUT_CHARS) -> str:
+    # Mode-neutral notice: this result serves both the streaming UI and
+    # non-streaming callers and must stay byte-identical with and without an
+    # output_callback (a regression-tested invariant), so it can't claim the
+    # user saw the full output.
     if len(text) > limit:
-        return text[:limit] + f"\n\n... (truncated, {len(text)} chars total)"
+        return text[:limit] + (
+            f"\n\n... (truncated to {limit} chars for the model; {len(text)} chars "
+            "total. The full output is not retained here; any files the code wrote "
+            "persist in the working directory.)"
+        )
     return text
 
 
+# ChatGPT code-interpreter path conventions models write out of habit; none
+# exist in the Studio sandbox, so a failure on one earns the retry hint.
+_MISSING_PATH_PREFIXES = (
+    "/mnt/data",
+    "/mnt/outputs",
+    "/home/sandbox",
+    "/workspace",
+    "/tmp/outputs",
+)
+
+# Matches the quoted path in a Python OSError str and the bare path in a bash
+# "No such file or directory" error; applied only to the error line.
+_QUOTED_ABS_PATH_RE = re.compile(r"""['"](/[^'"\n]+)['"]""")
+_BASH_ABS_PATH_RE = re.compile(r"(/[^\s:'\"]+):\s*No such file or directory")
+
+# The sandbox CWD is a per-thread dir under ~/studio_sandbox; an absolute path
+# under it is a genuine local miss, not a hallucinated out-of-sandbox write.
+_SANDBOX_ROOT = os.path.join(os.path.expanduser("~"), "studio_sandbox")
+
+
+def _missing_error_lines(output: str) -> list[str]:
+    """The lines that actually name a missing file (a FileNotFoundError message
+    or a bash "No such file or directory"). Traceback frame lines such as
+    ``File "/workspace/proj/script.py"`` are excluded, so an unrelated absolute
+    path mentioned elsewhere in the output is never treated as the failing one."""
+    return [
+        line
+        for line in output.splitlines()
+        if "No such file or directory" in line or "FileNotFoundError" in line
+    ]
+
+
+def _extract_missing_abs_path(output: str) -> str | None:
+    """Pull the absolute path a FileNotFoundError / bash error named, if any."""
+    for line in reversed(_missing_error_lines(output)):
+        m = _QUOTED_ABS_PATH_RE.search(line)
+        if m:
+            return m.group(1)
+        m = _BASH_ABS_PATH_RE.search(line)
+        if m:
+            return m.group(1)
+    return None
+
+
+def _is_outside_workdir(abs_path: str, workdir: str | None = None) -> bool:
+    """True when ``abs_path`` is not the working directory or under it.
+
+    ``workdir`` is the executor's actual working directory (defaults to the
+    sandbox root). Project-backed sessions run under a root OUTSIDE
+    ``~/studio_sandbox`` (see ``_get_workdir``), so a legitimate miss inside a
+    project must be judged against the real workdir, not a static sandbox root,
+    or it is wrongly classed as an external habit path.
+    """
+    try:
+        root = os.path.realpath(workdir or _SANDBOX_ROOT)
+        rp = os.path.realpath(abs_path)
+    except (OSError, ValueError):
+        return True
+    return rp != root and not rp.startswith(root + os.sep)
+
+
+def _missing_path_hint(output: str, workdir: str | None = None) -> str:
+    """Model-visible healing when an execution fails on an absolute path missing
+    in the sandbox (a code-interpreter habit path, or one invented from the CWD).
+    Detected on the full pre-truncation output; the hint echoes the failing path
+    so the model retries with the right relative name."""
+    error_lines = _missing_error_lines(output)
+    if not error_lines:
+        return ""
+    abs_path = _extract_missing_abs_path(output)
+    # A convention prefix is an out-of-sandbox signal only when the exact failing
+    # path could not be isolated; scoped to the failing-path error line(s) so a
+    # prefix mentioned elsewhere doesn't trigger a misleading hint.
+    convention = any(prefix in line for line in error_lines for prefix in _MISSING_PATH_PREFIXES)
+    if abs_path is not None:
+        # Judge the isolated path against the real workdir even when it matches a
+        # convention prefix, so a genuine miss inside a project rooted under such
+        # a prefix (e.g. /workspace/proj) is not steered out of its subdirectory.
+        if not _is_outside_workdir(abs_path, workdir):
+            return ""
+    elif not convention:
+        # Nothing marks this as an out-of-sandbox miss; stay silent.
+        return ""
+    if abs_path:
+        example = f"'{os.path.basename(abs_path)}', not '{abs_path}'"
+    else:
+        example = "'output.html', not '/mnt/data/output.html'"
+    return (
+        "\nHint: that absolute path does not exist in this sandbox. The current "
+        "working directory is writable and persists for this conversation; retry "
+        f"with a relative path (for example {example})."
+    )
+
+
+def _drain_process_output(
+    proc,
+    timeout,
+    output_callback,
+    cancel_event = None,
+    *,
+    pgid = None,
+) -> tuple[str, bool]:
+    """``proc.communicate(timeout=...)`` equivalent that also streams each
+    stdout line to ``output_callback`` as it is produced.
+
+    Returns ``(output, timed_out)``. The joined output is identical to what
+    ``communicate`` would return: the same TextIOWrapper decodes the stream,
+    so encoding, error replacement, and newline translation all match. On
+    timeout the process tree is killed (mirroring the non-streaming path).
+    With ``timeout=None`` the drain waits for EOF like ``communicate`` would,
+    stopping early only when ``cancel_event`` is set.
+    """
+    chunks: list[str] = []
+
+    # Captured before waiting so a stdout-holding grandchild can still be killed
+    # after the leader is reaped (getpgid then fails). Callers pass it in from
+    # right after Popen; fall back to capturing here for direct callers.
+    if pgid is None:
+        pgid = _capture_process_group(proc)
+
+    def _reader() -> None:
+        try:
+            for line in iter(proc.stdout.readline, ""):
+                chunks.append(line)
+                if output_callback is not None:
+                    try:
+                        output_callback(line)
+                    except Exception:  # noqa: BLE001 - observer must never kill the tool
+                        logger.debug("tool output_callback raised", exc_info = True)
+        except (ValueError, OSError):
+            pass  # pipe closed during kill
+
+    reader = threading.Thread(target = _reader, daemon = True)
+    reader.start()
+    started_at = time.monotonic()
+    timed_out = False
+    try:
+        proc.wait(timeout = timeout)
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        _kill_process_tree(proc)
+        # Also kill the pre-captured group in case the leader was reaped in the
+        # window before _kill_process_tree sampled its pgid, reaping a
+        # stdout-holding grandchild (matches the non-streaming timeout path).
+        _killpg_captured(pgid)
+        try:
+            proc.wait(timeout = 5)
+        except subprocess.TimeoutExpired:
+            pass
+    # A grandchild that inherited stdout can hold the pipe open past the main
+    # process's exit.
+    if not timed_out:
+        if timeout is not None:
+            # Wait out the remaining budget like communicate() would, polling
+            # cancel_event in slices (the cancel watcher is gone once the leader
+            # exits) so a chatty grandchild doesn't keep draining after a Stop.
+            # The normal path still reaches EOF on its own with the same bytes.
+            deadline = started_at + timeout
+            while reader.is_alive():
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    timed_out = True
+                    _killpg_captured(pgid)
+                    break
+                if cancel_event is not None and cancel_event.is_set():
+                    _killpg_captured(pgid)
+                    break
+                reader.join(timeout = min(0.5, remaining))
+        else:
+            # Unlimited timeout: drain until the pipe closes (like
+            # communicate(timeout=None)), stopping early only on cancellation.
+            while reader.is_alive():
+                if cancel_event is not None and cancel_event.is_set():
+                    _killpg_captured(pgid)
+                    break
+                reader.join(timeout = 0.5)
+    reader.join(timeout = 5)
+    return "".join(chunks), timed_out
+
+
 def _python_exec(
     code: str,
     cancel_event = None,
     timeout: int = _EXEC_TIMEOUT,
     session_id: str | None = None,
     disable_sandbox: bool = False,
+    output_callback = None,
 ) -> str:
     """Execute Python code in a subprocess sandbox.
 
     disable_sandbox (Bypass Permissions): skip the safety analysis and rlimit
     pre-exec, and use the host env minus secrets.
+    output_callback: optional callable(str) streamed each stdout line as it is
+    produced; the returned result is unchanged.
     """
     if not code or not code.strip():
         return "No code provided."
@@ -4907,23 +5499,32 @@ def _python_exec(
         else:
             popen_kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
 
-        proc = subprocess.Popen([sys.executable, tmp_path], **popen_kwargs)
+        # -u forces unbuffered child stdout so a bare print() streams live
+        # instead of sitting in the pipe's block buffer until exit. Applied
+        # unconditionally to stay byte-identical with and without streaming;
+        # unlike PYTHONUNBUFFERED=1 it never pollutes the child's os.environ.
+        proc = subprocess.Popen([sys.executable, "-u", tmp_path], **popen_kwargs)
+
+        # Capture the group before any watcher can reap the leader (see
+        # _capture_process_group); None on Windows.
+        pgid = _capture_process_group(proc)
 
-        # Spawn cancel watcher if we have a cancel event
         if cancel_event is not None:
             watcher = threading.Thread(
-                target = _cancel_watcher, args = (proc, cancel_event), daemon = True
+                target = _cancel_watcher,
+                args = (proc, cancel_event, 0.2, pgid),
+                daemon = True,
             )
             watcher.start()
 
-        try:
-            output, _ = proc.communicate(timeout = timeout)
-        except subprocess.TimeoutExpired:
-            _kill_process_tree(proc)
-            try:
-                proc.communicate(timeout = 5)
-            except subprocess.TimeoutExpired:
-                pass
+        # Always drain via _drain_process_output (output_callback may be None):
+        # it kills the captured group on cancellation, reaping a grandchild that
+        # outlived the leader, and returns bytes identical to communicate() so
+        # the streaming vs non-streaming result stays byte-identical.
+        output, timed_out = _drain_process_output(
+            proc, timeout, output_callback, cancel_event, pgid = pgid
+        )
+        if timed_out:
             return _truncate(f"Execution timed out after {timeout} seconds.")
 
         if cancel_event is not None and cancel_event.is_set():
@@ -4932,7 +5533,13 @@ def _python_exec(
         result = output or ""
         if proc.returncode != 0:
             result = f"Exit code {proc.returncode}:\n{result}"
+        # Detect the missing-path pattern on the full output (truncation could
+        # hide the trailing traceback); append the hint after truncation. External
+        # paths are judged against the real workdir (project sessions live outside
+        # the default sandbox root).
+        hint = _missing_path_hint(result, workdir)
         result = _truncate(result) if result.strip() else "(no output)"
+        result += hint
 
         # Detect new/overwritten images and append sentinel for the frontend
         if session_id and os.path.isdir(workdir):
@@ -4971,11 +5578,14 @@ def _bash_exec(
     timeout: int = _EXEC_TIMEOUT,
     session_id: str | None = None,
     disable_sandbox: bool = False,
+    output_callback = None,
 ) -> str:
     """Execute a bash command in a subprocess sandbox.
 
     disable_sandbox (Bypass Permissions): skip the command blocklist and rlimit
     pre-exec, and use the host env minus secrets.
+    output_callback: optional callable(str) streamed each stdout line as it is
+    produced; the returned result is unchanged.
     """
     if not command or not command.strip():
         return "No command provided."
@@ -5000,6 +5610,11 @@ def _bash_exec(
             stdout = subprocess.PIPE,
             stderr = subprocess.STDOUT,
             text = True,
+            # Match _python_exec: decode utf-8 with "replace" so invalid output
+            # bytes never raise UnicodeDecodeError (which the streaming reader
+            # thread would swallow), keeping both paths byte-identical.
+            encoding = "utf-8",
+            errors = "replace",
             cwd = workdir,
             env = safe_env,
         )
@@ -5010,20 +5625,25 @@ def _bash_exec(
 
         proc = subprocess.Popen(_get_shell_cmd(command), **popen_kwargs)
 
+        # Capture the group before any watcher can poll/reap the leader (see
+        # _python_exec); None on Windows.
+        pgid = _capture_process_group(proc)
+
         if cancel_event is not None:
             watcher = threading.Thread(
-                target = _cancel_watcher, args = (proc, cancel_event), daemon = True
+                target = _cancel_watcher,
+                args = (proc, cancel_event, 0.2, pgid),
+                daemon = True,
             )
             watcher.start()
 
-        try:
-            output, _ = proc.communicate(timeout = timeout)
-        except subprocess.TimeoutExpired:
-            _kill_process_tree(proc)
-            try:
-                proc.communicate(timeout = 5)
-            except subprocess.TimeoutExpired:
-                pass
+        # Always drain via _drain_process_output (see _python_exec): kills the
+        # captured group on cancellation and returns bytes identical to
+        # communicate(), keeping streaming vs non-streaming byte-identical.
+        output, timed_out = _drain_process_output(
+            proc, timeout, output_callback, cancel_event, pgid = pgid
+        )
+        if timed_out:
             return _truncate(f"Execution timed out after {timeout} seconds.")
 
         if cancel_event is not None and cancel_event.is_set():
@@ -5032,7 +5652,10 @@ def _bash_exec(
         result = output or ""
         if proc.returncode != 0:
             result = f"Exit code {proc.returncode}:\n{result}"
-        return _truncate(result) if result.strip() else "(no output)"
+        # Same missing-path healing as _python_exec.
+        hint = _missing_path_hint(result, workdir)
+        result = _truncate(result) if result.strip() else "(no output)"
+        return result + hint
 
     except Exception as e:
         return f"Execution error: {e}"
diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.py
index 9bf57fa607..0541a81ff2 100644
--- a/studio/backend/routes/inference.py
+++ b/studio/backend/routes/inference.py
@@ -1083,6 +1083,10 @@ _OPENAI_PASSTHROUGH_PREHEADER_STATUS_WINDOW_S = 0.1
 _OPENAI_PASSTHROUGH_PENDING_RESPONSE_KEEPALIVE_S = 5.0
 _OPENAI_PASSTHROUGH_SSE_KEEPALIVE = ": keep-alive\n\n"
 _OPENAI_LLAMA_ADMISSION_POLL_S = 0.25
+# Idle window before a local tool-loop stream emits an SSE keepalive comment
+# (e.g. prompt prefill between tool iterations). A second layer atop the
+# tool_stream_exec heartbeats, keeping proxies (Cloudflare drops idle at ~100s).
+_LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S = 15.0
 
 
 def _openai_llama_admission_capacity(request: Optional[Request], llama_backend = None) -> int:
@@ -2298,6 +2302,36 @@ async def _stop_local_disconnect_cancel_watcher(watcher) -> None:
         pass
 
 
+async def _drain_pending_next_task(task, cancel_event) -> None:
+    """Wait for a pending ``asyncio.to_thread(next, gen, ...)`` task to finish
+    before its generator is closed.
+
+    On disconnect a ``next(gen)`` call may still run in a worker thread;
+    cancelling the awaiting task does NOT stop it, and ``gen.close()`` mid-
+    ``next(gen)`` raises ``ValueError: generator already executing``, leaking the
+    generator's cleanup. So re-set the cancel flag (the generator polls it) and
+    shield the task until the worker returns. No-op when there is no pending task.
+    """
+    if task is None:
+        return
+    if cancel_event is not None:
+        cancel_event.set()
+    while not task.done():
+        try:
+            await asyncio.shield(task)
+        except asyncio.CancelledError:
+            if cancel_event is not None:
+                cancel_event.set()
+            continue
+        except Exception:
+            break
+    if task.done():
+        try:
+            task.exception()
+        except (asyncio.CancelledError, Exception):
+            pass
+
+
 # Centralized local/server tool nudge. Keep render_html guidance gated to turns
 # where the canvas tool is actually present in the tool schema; otherwise
 # small local models can hallucinate a missing tool call instead of following
@@ -7462,13 +7496,35 @@ async def openai_chat_completions(
                             asyncio.to_thread(next, gen, _tool_sentinel)
                         )
                         try:
-                            event = await asyncio.shield(next_task)
+                            # Stall-timeout wait: keepalive while the generator stays
+                            # silent (e.g. prefill between tool iterations). asyncio.wait
+                            # never cancels next_task, matching the finally-drain shield.
+                            while True:
+                                done_tasks, _ = await asyncio.wait(
+                                    {next_task},
+                                    timeout = _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S,
+                                )
+                                if done_tasks:
+                                    break
+                                yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                            event = next_task.result()
                         finally:
                             if next_task.done():
                                 next_task = None
                         if event is _tool_sentinel:
                             break
 
+                        if event["type"] == "heartbeat":
+                            # Tool-wrapper heartbeat while a server-side tool blocks; keeps SSE alive.
+                            yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                            continue
+
+                        if event["type"] in ("tool_output", "tool_args"):
+                            # Live stdout/stderr or tool-call arguments, forwarded
+                            # verbatim for the UI. Final result still arrives in tool_end.
+                            yield f"data: {json.dumps(event)}\n\n"
+                            continue
+
                         if event["type"] == "status":
                             # Empty status marks an iteration boundary in the
                             # GGUF tool loop (e.g. after a re-prompt). Reset the
@@ -8018,7 +8074,18 @@ async def openai_chat_completions(
                             asyncio.to_thread(next, gen, _gguf_sentinel)
                         )
                         try:
-                            cumulative = await asyncio.shield(next_task)
+                            # Stall-timeout wait: keepalive while the generator stays
+                            # silent (e.g. no-tool prefill). asyncio.wait never cancels
+                            # next_task, matching the finally-drain shield (see GGUF stream).
+                            while True:
+                                done_tasks, _ = await asyncio.wait(
+                                    {next_task},
+                                    timeout = _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S,
+                                )
+                                if done_tasks:
+                                    break
+                                yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                            cumulative = next_task.result()
                         finally:
                             if next_task.done():
                                 next_task = None
@@ -8709,6 +8776,7 @@ async def openai_chat_completions(
 
         async def sf_tool_stream():
             gen = None
+            _sf_next_task = None
             disconnect_watcher = asyncio.create_task(
                 _await_disconnect_then_cancel(request, cancel_event)
             )
@@ -8740,10 +8808,35 @@ async def openai_chat_completions(
                         api_monitor.finish(monitor_id, "cancelled")
                         return
 
-                    event = await asyncio.to_thread(next, gen, _sf_tool_sentinel)
+                    # Stall keepalive (see GGUF tool stream): silent backend segments
+                    # must not leave the SSE stream idle past proxy timeouts.
+                    _sf_next_task = asyncio.create_task(
+                        asyncio.to_thread(next, gen, _sf_tool_sentinel)
+                    )
+                    while True:
+                        _sf_done, _ = await asyncio.wait(
+                            {_sf_next_task},
+                            timeout = _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S,
+                        )
+                        if _sf_done:
+                            break
+                        yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                    event = _sf_next_task.result()
+                    # Done; drop the reference so the finally-block drain no-ops.
+                    _sf_next_task = None
                     if event is _sf_tool_sentinel:
                         break
 
+                    if event["type"] == "heartbeat":
+                        # Tool-execution wrapper heartbeat -> SSE keepalive.
+                        yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                        continue
+
+                    if event["type"] in ("tool_output", "tool_args"):
+                        # Live stdout/stderr, or tool-call arguments as the model writes them.
+                        yield f"data: {json.dumps(event)}\n\n"
+                        continue
+
                     if event["type"] == "status":
                         if not event["text"]:
                             # Iteration boundary: flush reasoning, then a fresh prefilled extractor for the next turn.
@@ -8835,9 +8928,15 @@ async def openai_chat_completions(
                 yield _openai_stream_error_sse(error_chunk)
             finally:
                 await _stop_local_disconnect_cancel_watcher(disconnect_watcher)
+                # Drain a still-running next(gen) worker before closing: closing
+                # mid-next(gen) raises ValueError('generator already executing') and
+                # skips the generator's cleanup finally. Matches the GGUF tool stream.
+                await _drain_pending_next_task(_sf_next_task, cancel_event)
                 if gen is not None:
                     try:
-                        gen.close()
+                        # Offload the close so the generator's cleanup runs off the event
+                        # loop (matches the GGUF SSE path); a disconnect can't stall the loop.
+                        await asyncio.to_thread(gen.close)
                     except (RuntimeError, ValueError):
                         pass
                 _sf_tracker.__exit__(None, None, None)
@@ -9027,6 +9126,8 @@ async def openai_chat_completions(
         _tracker.__enter__()
 
         async def stream_chunks():
+            gen = None
+            _next_task = None
             disconnect_watcher = asyncio.create_task(
                 _await_disconnect_then_cancel(request, cancel_event)
             )
@@ -9041,23 +9142,30 @@ async def openai_chat_completions(
                 prev_text = ""
                 # Split prefilled <think> into reasoning_content deltas (GGUF parity); single turn, serves MLX.
                 reasoning_extractor = _new_sf_reasoning_extractor()
-                # Run the sync generator in a thread pool to avoid blocking the
-                # event loop. Critical for compare mode: two SSE requests arrive
-                # concurrently but the orchestrator serializes them via
-                # _gen_lock; without run_in_executor the second request's
-                # blocking lock acquisition would freeze the entire event loop,
-                # stalling both streams.
+                # Run the sync generator in a worker thread so it can't block the event
+                # loop. Critical for compare mode: a second request's blocking _gen_lock
+                # acquisition would otherwise freeze the loop and stall both streams.
                 _DONE = object()  # sentinel for generator exhaustion
-                loop = asyncio.get_event_loop()
                 gen = generate()
                 while True:
                     if cancel_event.is_set():
                         backend.reset_generation_state()
                         break
-                    # next(gen, _DONE) returns _DONE instead of raising
-                    # StopIteration -- StopIteration can't propagate through
-                    # asyncio futures (Python limitation).
-                    cumulative = await loop.run_in_executor(None, next, gen, _DONE)
+                    # Stall keepalive (see safetensors tool stream) each window while
+                    # next(gen) runs in a worker. next(gen, _DONE) returns _DONE rather
+                    # than raising StopIteration (which can't cross asyncio futures).
+                    _next_task = asyncio.create_task(asyncio.to_thread(next, gen, _DONE))
+                    while True:
+                        _done_tasks, _ = await asyncio.wait(
+                            {_next_task},
+                            timeout = _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S,
+                        )
+                        if _done_tasks:
+                            break
+                        yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                    cumulative = _next_task.result()
+                    # Done; drop the reference so the finally-block drain no-ops.
+                    _next_task = None
                     if cumulative is _DONE:
                         break
                     if await request.is_disconnected():
@@ -9180,6 +9288,17 @@ async def openai_chat_completions(
                 yield _openai_stream_error_sse(error_chunk)
             finally:
                 await _stop_local_disconnect_cancel_watcher(disconnect_watcher)
+                # Drain a still-running next(gen) worker before closing: closing
+                # mid-next(gen) raises ValueError('generator already executing') and
+                # skips the generator's cleanup finally. Matches the safetensors stream.
+                await _drain_pending_next_task(_next_task, cancel_event)
+                if gen is not None:
+                    try:
+                        # Offload the close so the generator's cleanup runs off the event
+                        # loop (matches the GGUF SSE path); a disconnect can't stall the loop.
+                        await asyncio.to_thread(gen.close)
+                    except (RuntimeError, ValueError):
+                        pass
                 _tracker.__exit__(None, None, None)
 
         return _SameTaskStreamingResponse(
@@ -12389,8 +12508,12 @@ async def _anthropic_tool_stream(
         ends_on_tool_use = False
         tool_blocks_emitted = 0
         drop_until_tool_end = False
+        # Last drop-branch keepalive, seeded to stream start so a chatty tool busy
+        # past the stall window still gets a keepalive though its events are dropped.
+        _last_drop_keepalive = time.monotonic()
 
         gen = run_gen()
+        _next_task = None
         # Watcher to cancel on disconnect: the in-loop poll fires only between
         # events, so a mid-prefill disconnect would otherwise hold the decode slot.
         disconnect_watcher = asyncio.create_task(
@@ -12401,13 +12524,42 @@ async def _anthropic_tool_stream(
                 if cancel_event.is_set() or await request.is_disconnected():
                     cancel_event.set()
                     return
-                event = await asyncio.to_thread(next, gen, _sentinel)
+                # Stall keepalive (see GGUF tool stream): silent backend segments
+                # must not leave the SSE stream idle past proxy timeouts.
+                _next_task = asyncio.create_task(asyncio.to_thread(next, gen, _sentinel))
+                while True:
+                    _done_tasks, _ = await asyncio.wait(
+                        {_next_task},
+                        timeout = _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S,
+                    )
+                    if _done_tasks:
+                        break
+                    yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                event = _next_task.result()
+                # Done; drop the reference so the finally-block drain no-ops.
+                _next_task = None
                 if event is _sentinel:
                     break
                 etype = event.get("type")
+                if etype == "heartbeat":
+                    # Tool-wrapper heartbeat -> SSE keepalive, checked BEFORE the drop
+                    # skip: a dropped tool still runs server-side and its events keep the
+                    # stall keepalive from firing, so dropping heartbeats would go silent.
+                    yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                    continue
+                if etype in ("tool_output", "tool_args"):
+                    # Live stdout / arg streaming have no Anthropic Messages equivalent
+                    # (the full call/result follow in tool_use / tool_result), so drop them.
+                    # They keep the stall keepalive from firing, so a chatty tool would go
+                    # silent past the ~100s proxy cap; emit a rate-limited keepalive instead.
+                    _now = time.monotonic()
+                    if _now - _last_drop_keepalive >= _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S:
+                        _last_drop_keepalive = _now
+                        yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                    continue
                 if drop_until_tool_end:
-                    # disable_parallel_tool_use: a later tool call is being
-                    # dropped — skip every event until (and including) its tool_end.
+                    # disable_parallel_tool_use: skip every event until (and
+                    # including) this dropped tool call's tool_end.
                     if etype == "tool_end":
                         drop_until_tool_end = False
                     continue
@@ -12448,12 +12600,24 @@ async def _anthropic_tool_stream(
                     yield line
         except Exception as e:
             logger.error("anthropic_messages stream error: %s", e)
-            _error_event = _anthropic_stream_error_event(e)
+            # force = True so an unclassified mid-stream failure (llama-server crash,
+            # decode OOM, dropped socket) still emits an SSE error and returns, instead
+            # of a normal message_stop that masks a truncated turn as a clean finish.
+            _error_event = _anthropic_stream_error_event(e, force = True)
             if _error_event is not None:
                 yield _error_event
                 return
         finally:
             await _stop_local_disconnect_cancel_watcher(disconnect_watcher)
+            # Drain a still-running next(gen) worker before closing, so a mid-prefill
+            # disconnect releases the thread/generator/tool resources. Closing first
+            # would race into ValueError('generator already executing').
+            await _drain_pending_next_task(_next_task, cancel_event)
+            if gen is not None:
+                try:
+                    await asyncio.to_thread(gen.close)
+                except (RuntimeError, ValueError):
+                    pass
 
         stop_reason = openai_finish_to_anthropic_stop(
             captured_finish_reason, had_tool_calls = ends_on_tool_use
@@ -12490,6 +12654,7 @@ async def _anthropic_plain_stream(
         captured_finish_reason = None
 
         gen = run_gen()
+        _next_task = None
         # Watcher to cancel on disconnect: the in-loop poll fires only between
         # chunks, so a mid-prefill disconnect would otherwise hold the decode slot.
         disconnect_watcher = asyncio.create_task(
@@ -12500,7 +12665,20 @@ async def _anthropic_plain_stream(
                 if cancel_event.is_set() or await request.is_disconnected():
                     cancel_event.set()
                     return
-                cumulative = await asyncio.to_thread(next, gen, _sentinel)
+                # Stall keepalive (see Anthropic tool stream) each window while
+                # next(gen) runs in a worker.
+                _next_task = asyncio.create_task(asyncio.to_thread(next, gen, _sentinel))
+                while True:
+                    _done_tasks, _ = await asyncio.wait(
+                        {_next_task},
+                        timeout = _LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S,
+                    )
+                    if _done_tasks:
+                        break
+                    yield _OPENAI_PASSTHROUGH_SSE_KEEPALIVE
+                cumulative = _next_task.result()
+                # Done; drop the reference so the finally-block drain no-ops.
+                _next_task = None
                 if cumulative is _sentinel:
                     break
                 if isinstance(cumulative, dict):
@@ -12516,12 +12694,24 @@ async def _anthropic_plain_stream(
                     yield line
         except Exception as e:
             logger.error("anthropic_messages stream error: %s", e)
-            _error_event = _anthropic_stream_error_event(e)
+            # force = True so an unclassified mid-stream failure (llama-server crash,
+            # decode OOM, dropped socket) still emits an SSE error and returns, instead
+            # of a normal message_stop that masks a truncated turn as a clean finish.
+            _error_event = _anthropic_stream_error_event(e, force = True)
             if _error_event is not None:
                 yield _error_event
                 return
         finally:
             await _stop_local_disconnect_cancel_watcher(disconnect_watcher)
+            # Drain a still-running next(gen) worker before closing, so a mid-prefill
+            # disconnect releases the thread/generator/model resources. Closing first
+            # would race into ValueError('generator already executing').
+            await _drain_pending_next_task(_next_task, cancel_event)
+            if gen is not None:
+                try:
+                    await asyncio.to_thread(gen.close)
+                except (RuntimeError, ValueError):
+                    pass
 
         stop_reason = openai_finish_to_anthropic_stop(captured_finish_reason, had_tool_calls = False)
         for line in emitter.finish(stop_reason = stop_reason, stop_sequence = None):
diff --git a/studio/backend/tests/test_anthropic_messages.py b/studio/backend/tests/test_anthropic_messages.py
index 10cbc64ad3..3b0ea37372 100644
--- a/studio/backend/tests/test_anthropic_messages.py
+++ b/studio/backend/tests/test_anthropic_messages.py
@@ -1631,6 +1631,48 @@ class TestAnthropicMessagesToolRouting:
         assert entry["status"] == "cancelled"
         assert monitor.active_count() == 0
 
+    @staticmethod
+    def _sse_blob(chunks):
+        # StreamingResponse may hand back str or already-encoded bytes.
+        return "".join(c.decode() if isinstance(c, (bytes, bytearray)) else c for c in chunks)
+
+    def test_plain_streaming_unclassified_error_emits_error_event(self, monkeypatch):
+        # An unclassified mid-stream failure must surface as an SSE `error` event
+        # and stop, not a message_stop that masks a truncated turn as clean.
+        def _gen_boom(**_kwargs):
+            yield "partial"
+            raise RuntimeError("llama-server crashed mid-decode")
+
+        _mock_backend(monkeypatch, generate_chat_completion = _gen_boom)
+        payload = _basic_payload(stream = True)
+
+        response = _drive(anthropic_messages(payload, request = self._Request(), current_subject = "t"))
+        blob = self._sse_blob(self._consume_response(response))
+
+        assert "event: error" in blob
+        assert '"type": "error"' in blob
+        assert "event: message_stop" not in blob
+
+    def test_tool_streaming_unclassified_error_emits_error_event(self, monkeypatch):
+        # Same guarantee on the tool-calling stream path.
+        def _gen_tools_boom(**_kwargs):
+            yield {"type": "content", "text": "partial"}
+            raise RuntimeError("llama-server crashed mid-decode")
+
+        _mock_backend(monkeypatch, generate_chat_completion_with_tools = _gen_tools_boom)
+        payload = _basic_payload(
+            stream = True,
+            enable_tools = True,
+            tools = [{"type": "web_search_20250305", "name": "web_search"}],
+        )
+
+        response = _drive(anthropic_messages(payload, request = self._Request(), current_subject = "t"))
+        blob = self._sse_blob(self._consume_response(response))
+
+        assert "event: error" in blob
+        assert '"type": "error"' in blob
+        assert "event: message_stop" not in blob
+
     def test_mixed_server_and_client_tools_rejected_with_400(self, monkeypatch):
         _mock_backend(monkeypatch)
         payload = _basic_payload(
@@ -2076,3 +2118,339 @@ def test_resumed_null_assistant_between_users_coalesced_on_messages_route(monkey
     if isinstance(merged, list):
         merged = " ".join(p.get("text", "") for p in merged if isinstance(p, dict))
     assert "first question" in merged and "please continue" in merged
+
+
+def test_disable_parallel_tool_use_forwards_heartbeats_while_dropping():
+    """Heartbeats from a parallel-disabled, dropped tool call must still reach
+    the client as SSE keepalives: the dropped call runs server-side and the
+    stall keepalive never fires while the generator keeps producing events, so
+    swallowing them recreates the silent window keepalives exist to prevent."""
+    import threading as _threading
+
+    from routes.inference import (
+        _OPENAI_PASSTHROUGH_SSE_KEEPALIVE,
+        _anthropic_tool_stream,
+    )
+
+    def run_gen():
+        def gen():
+            yield {
+                "type": "tool_start",
+                "tool_name": "python",
+                "tool_call_id": "call_0",
+                "arguments": {},
+            }
+            yield {"type": "heartbeat"}
+            yield {
+                "type": "tool_end",
+                "tool_name": "python",
+                "tool_call_id": "call_0",
+                "result": "r1",
+            }
+            # Second call: dropped by disable_parallel_tool_use, still executed
+            # server-side (heartbeats + live output).
+            yield {
+                "type": "tool_start",
+                "tool_name": "python",
+                "tool_call_id": "call_1",
+                "arguments": {},
+            }
+            yield {"type": "heartbeat"}
+            yield {
+                "type": "tool_output",
+                "tool_name": "python",
+                "tool_call_id": "call_1",
+                "text": "x",
+            }
+            yield {"type": "heartbeat"}
+            yield {
+                "type": "tool_end",
+                "tool_name": "python",
+                "tool_call_id": "call_1",
+                "result": "r2",
+            }
+            yield {"type": "content", "text": "final answer"}
+
+        return gen()
+
+    async def _drive():
+        async def _is_disconnected():
+            return False
+
+        request = SimpleNamespace(is_disconnected = _is_disconnected)
+        resp = await _anthropic_tool_stream(
+            request,
+            _threading.Event(),
+            run_gen,
+            "msg_hb",
+            "m",
+            disable_parallel_tool_use = True,
+        )
+        return [chunk async for chunk in resp.body_iterator]
+
+    chunks = asyncio.run(_drive())
+    keepalives = [c for c in chunks if c == _OPENAI_PASSTHROUGH_SSE_KEEPALIVE]
+    # One heartbeat inside the kept call, two inside the dropped window.
+    assert len(keepalives) >= 3
+    # The dropped call must not surface as a second tool_use block.
+    tool_use_starts = [c for c in chunks if "content_block_start" in c and '"tool_use"' in c]
+    assert len(tool_use_starts) == 1
+
+
+def test_dropped_tool_output_events_emit_rate_limited_keepalives(monkeypatch):
+    """A chatty tool streaming tool_output/tool_args with no heartbeats keeps the
+    generator busy (stall keepalive never fires); the Anthropic path can't
+    translate those events and drops them. Dropping silently would let an idle
+    proxy kill the stream, so the drop branch emits a rate-limited keepalive."""
+    import threading as _threading
+
+    import routes.inference as inf_mod
+    from routes.inference import (
+        _OPENAI_PASSTHROUGH_SSE_KEEPALIVE,
+        _anthropic_tool_stream,
+    )
+
+    # Deterministic clock: only the drop-branch keepalive uses time.monotonic
+    # here, so jumping past the stall window per call makes each dropped event
+    # cross the rate-limit threshold. asyncio.wait uses the loop clock and
+    # next(gen) returns promptly, so the outer stall keepalive never fires --
+    # every keepalive here is from the drop branch.
+    _real_time = inf_mod.time
+    _tick = {"v": 0.0}
+
+    def _fast_monotonic():
+        _tick["v"] += 100.0
+        return _tick["v"]
+
+    fake_time = SimpleNamespace(
+        monotonic = _fast_monotonic,
+        sleep = _real_time.sleep,
+        time = _real_time.time,
+        perf_counter = _real_time.perf_counter,
+    )
+    monkeypatch.setattr(inf_mod, "time", fake_time)
+
+    n_output = 4
+
+    def run_gen():
+        def gen():
+            yield {
+                "type": "tool_start",
+                "tool_name": "python",
+                "tool_call_id": "call_0",
+                "arguments": {},
+            }
+            # Chatty streamed stdout, no heartbeats.
+            for i in range(n_output):
+                yield {
+                    "type": "tool_output",
+                    "tool_name": "python",
+                    "tool_call_id": "call_0",
+                    "text": f"line {i}\n",
+                }
+            yield {
+                "type": "tool_end",
+                "tool_name": "python",
+                "tool_call_id": "call_0",
+                "result": "done",
+            }
+            yield {"type": "content", "text": "final answer"}
+
+        return gen()
+
+    async def _drive():
+        async def _is_disconnected():
+            return False
+
+        request = SimpleNamespace(is_disconnected = _is_disconnected)
+        resp = await _anthropic_tool_stream(
+            request,
+            _threading.Event(),
+            run_gen,
+            "msg_drop_ka",
+            "m",
+        )
+        return [chunk async for chunk in resp.body_iterator]
+
+    chunks = asyncio.run(_drive())
+    keepalives = [c for c in chunks if c == _OPENAI_PASSTHROUGH_SSE_KEEPALIVE]
+    assert len(keepalives) == n_output
+    # Final answer still reaches the client (drop is transport-only).
+    assert any("final answer" in c for c in chunks)
+
+
+def test_parallel_disabled_dropped_call_output_emits_rate_limited_keepalives(monkeypatch):
+    """Under disable_parallel_tool_use a chatty second call is dropped whole
+    (drop_until_tool_end). Its tool_output/tool_args events must still emit
+    rate-limited keepalives: the drop window can last minutes with no heartbeats
+    and no stall keepalive, so swallowing them silently would let an idle proxy
+    kill the stream. The keepalive branch runs before the drop skip."""
+    import threading as _threading
+
+    import routes.inference as inf_mod
+    from routes.inference import (
+        _OPENAI_PASSTHROUGH_SSE_KEEPALIVE,
+        _anthropic_tool_stream,
+    )
+
+    # Deterministic clock: jumps past the stall window per call (see sibling test).
+    _real_time = inf_mod.time
+    _tick = {"v": 0.0}
+
+    def _fast_monotonic():
+        _tick["v"] += 100.0
+        return _tick["v"]
+
+    fake_time = SimpleNamespace(
+        monotonic = _fast_monotonic,
+        sleep = _real_time.sleep,
+        time = _real_time.time,
+        perf_counter = _real_time.perf_counter,
+    )
+    monkeypatch.setattr(inf_mod, "time", fake_time)
+
+    n_output = 4
+
+    def run_gen():
+        def gen():
+            # First (kept) call.
+            yield {
+                "type": "tool_start",
+                "tool_name": "python",
+                "tool_call_id": "call_0",
+                "arguments": {},
+            }
+            yield {
+                "type": "tool_end",
+                "tool_name": "python",
+                "tool_call_id": "call_0",
+                "result": "r1",
+            }
+            # Second call: dropped whole by disable_parallel_tool_use but still
+            # executed server-side, streaming chatty stdout with no heartbeats.
+            yield {
+                "type": "tool_start",
+                "tool_name": "python",
+                "tool_call_id": "call_1",
+                "arguments": {},
+            }
+            for i in range(n_output):
+                yield {
+                    "type": "tool_output",
+                    "tool_name": "python",
+                    "tool_call_id": "call_1",
+                    "text": f"line {i}\n",
+                }
+            yield {
+                "type": "tool_end",
+                "tool_name": "python",
+                "tool_call_id": "call_1",
+                "result": "r2",
+            }
+            yield {"type": "content", "text": "final answer"}
+
+        return gen()
+
+    async def _drive():
+        async def _is_disconnected():
+            return False
+
+        request = SimpleNamespace(is_disconnected = _is_disconnected)
+        resp = await _anthropic_tool_stream(
+            request,
+            _threading.Event(),
+            run_gen,
+            "msg_drop_ka2",
+            "m",
+            disable_parallel_tool_use = True,
+        )
+        return [chunk async for chunk in resp.body_iterator]
+
+    chunks = asyncio.run(_drive())
+    keepalives = [c for c in chunks if c == _OPENAI_PASSTHROUGH_SSE_KEEPALIVE]
+    assert len(keepalives) == n_output
+    # The dropped call must not surface as a second tool_use block.
+    tool_use_starts = [c for c in chunks if "content_block_start" in c and '"tool_use"' in c]
+    assert len(tool_use_starts) == 1
+    assert any("final answer" in c for c in chunks)
+
+
+def test_plain_stream_emits_keepalive_during_prompt_stall(monkeypatch):
+    """No-tool Anthropic stream must emit SSE keepalives while a long prompt
+    prefill blocks next(gen), matching the tool stream (finding 5). The old
+    single unbounded to_thread(next, ...) could sit silent past a proxy idle cap."""
+    import threading as _threading
+    import time as _time
+
+    from routes import inference as inf_mod
+    from routes.inference import _OPENAI_PASSTHROUGH_SSE_KEEPALIVE, _anthropic_plain_stream
+
+    monkeypatch.setattr(inf_mod, "_LOCAL_TOOL_STREAM_STALL_KEEPALIVE_S", 0.05)
+
+    def run_gen():
+        def gen():
+            _time.sleep(0.24)  # stall past several shortened keepalive windows
+            yield "hello world"
+
+        return gen()
+
+    async def _drive():
+        async def _is_disconnected():
+            return False
+
+        request = SimpleNamespace(is_disconnected = _is_disconnected)
+        resp = await _anthropic_plain_stream(
+            request, _threading.Event(), run_gen, "msg_plain_ka", "m"
+        )
+        return [chunk async for chunk in resp.body_iterator]
+
+    chunks = asyncio.run(_drive())
+    keepalives = [c for c in chunks if c == _OPENAI_PASSTHROUGH_SSE_KEEPALIVE]
+    assert len(keepalives) >= 2
+    assert any("hello world" in c for c in chunks)
+
+
+def test_plain_stream_closes_generator_on_disconnect():
+    """On disconnect the no-tool teardown must drain any pending worker and close
+    the generator (finding 6). The old finally only stopped the disconnect
+    watcher, leaking the generator. A fake generator records close() so the
+    teardown is asserted deterministically, not via GC."""
+    import threading as _threading
+
+    from routes.inference import _anthropic_plain_stream
+
+    closed = _threading.Event()
+
+    class _FakeGen:
+        def __init__(self):
+            self._items = iter(["tok0", "tok1", "tok2", "tok3"])
+
+        def __next__(self):
+            return next(self._items)
+
+        def close(self):
+            closed.set()
+
+    def run_gen():
+        return _FakeGen()
+
+    state = {"disconnected": False}
+
+    async def _drive():
+        async def _is_disconnected():
+            return state["disconnected"]
+
+        request = SimpleNamespace(is_disconnected = _is_disconnected)
+        resp = await _anthropic_plain_stream(
+            request, _threading.Event(), run_gen, "msg_plain_close", "m"
+        )
+        out = []
+        async for chunk in resp.body_iterator:
+            out.append(chunk)
+            if "tok0" in chunk:
+                # Client drops after the first token; the next loop turn tears down.
+                state["disconnected"] = True
+        return out
+
+    asyncio.run(_drive())
+    assert closed.is_set()
diff --git a/studio/backend/tests/test_bypass_permissions.py b/studio/backend/tests/test_bypass_permissions.py
index 585aa207a7..2635f4e7c8 100644
--- a/studio/backend/tests/test_bypass_permissions.py
+++ b/studio/backend/tests/test_bypass_permissions.py
@@ -13,6 +13,7 @@ never gating under bypass.
 Run with: ``PYTHONPATH=studio/backend python -m pytest studio/backend/tests/test_bypass_permissions.py -q``
 """
 
+import io
 import os
 import sys
 
@@ -94,10 +95,23 @@ def test_safe_env_excludes_host_and_secret(monkeypatch, tmp_path):
 
 
 class _FakeProc:
-    returncode = 0
+    """A subprocess.Popen double for the drain path (``tools._drain_process_output``):
+    a readable ``stdout`` pipe yielding the fake output then EOF, plus
+    ``wait()`` / ``poll()`` / ``pid``. The pid is non-existent so
+    ``_capture_process_group``'s ``os.getpgid`` returns None; ``wait`` returns
+    immediately so the drain never kills.
+    """
 
-    def communicate(self, timeout = None):
-        return ("FAKEOUT", None)
+    returncode = 0
+    # Unlikely-to-exist pid: os.getpgid raises ProcessLookupError (caught) -> None.
+    pid = 2**22
+
+    def __init__(self):
+        # Readable stdout: iter(readline, "") yields "FAKEOUT" then hits EOF.
+        self.stdout = io.StringIO("FAKEOUT")
+
+    def wait(self, timeout = None):
+        return 0
 
     def poll(self):
         return 0
diff --git a/studio/backend/tests/test_llama_cpp_tool_loop.py b/studio/backend/tests/test_llama_cpp_tool_loop.py
index 8ccee79a4e..c3161c5714 100644
--- a/studio/backend/tests/test_llama_cpp_tool_loop.py
+++ b/studio/backend/tests/test_llama_cpp_tool_loop.py
@@ -1498,6 +1498,59 @@ def test_textual_mistral_marker_not_leaked_when_inline_with_preface(monkeypatch)
     assert any("Let me search." in t for t in content_texts)
 
 
+def test_textual_explicit_id_reuses_provisional_card(monkeypatch):
+    # A textual Mistral-style call with an explicit ``id`` must reconcile onto the
+    # open provisional TEXT card (keyed "call_0"), not spawn a duplicate under the
+    # explicit id (which the parser keeps for execution).
+    big_query = "cats " * 80  # push the drained call past the provisional floor
+    call = "[TOOL_CALLS]" + json.dumps(
+        [{"name": "web_search", "arguments": {"query": big_query}, "id": "explicit-42"}]
+    )
+    assert len(call) > 256
+    # Small chunks so the provisional card opens mid-generation (a single-shot
+    # delta parses instantly and never shows a provisional to exercise).
+    chunks = [call[i : i + 24] for i in range(0, len(call), 24)]
+    streams = [
+        [_sse({"content": c}) for c in chunks] + [_done()],
+        [_sse({"content": "done"}), _done()],
+    ]
+    payloads: list[dict] = []
+    backend = _make_backend(monkeypatch, streams, payloads)
+    calls: list[tuple[str, dict]] = []
+
+    def fake_execute_tool(name, arguments, **_kwargs):
+        calls.append((name, arguments))
+        return "result"
+
+    monkeypatch.setattr("core.inference.tools.execute_tool", fake_execute_tool)
+
+    events = list(
+        backend.generate_chat_completion_with_tools(
+            messages = [{"role": "user", "content": "search"}],
+            tools = [{"type": "function", "function": {"name": "web_search"}}],
+            max_tool_iterations = 1,
+        )
+    )
+
+    assert calls == [("web_search", {"query": big_query})]
+    tool_starts = [e for e in events if e.get("type") == "tool_start"]
+    # Empty-args card = provisional open; full-args card = reconciled real start.
+    provisional = [e for e in tool_starts if not e.get("arguments")]
+    real = [e for e in tool_starts if e.get("arguments", {}).get("query")]
+    assert len(provisional) == 1, tool_starts  # provisional actually opened
+    prov_id = provisional[0]["tool_call_id"]
+    # Exactly one real card, sharing the provisional id, not a duplicate under
+    # the explicit "explicit-42" id.
+    assert len(real) == 1, tool_starts
+    assert real[0]["tool_call_id"] == prov_id
+    assert real[0]["tool_name"] == "web_search"
+    assert {e["tool_call_id"] for e in tool_starts} == {prov_id}
+    # A single tool_end reconciles the card; no stale empty-result close.
+    ends = [e for e in events if e.get("type") == "tool_end"]
+    assert [e["tool_call_id"] for e in ends] == [prov_id]
+    assert ends[0]["result"] == "result"
+
+
 def test_textual_llama_python_tag_marker_not_leaked(monkeypatch):
     # Same leak class for the Llama-3 built-in ``<|python_tag|>NAME.call(...)`` form.
     streams = [
@@ -2916,3 +2969,204 @@ def test_gguf_valid_tool_calls_respect_max_tool_iterations(monkeypatch):
         m.get("role") == "user" and "used all available tool calls" in m.get("content", "")
         for m in payloads[2]["messages"]
     ), payloads[2]["messages"]
+
+
+# ── Live tool-call argument streaming (tool_args events) ─────────────────────
+
+
+def _python_tool_schema() -> list[dict]:
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "python",
+                "description": "Run python code.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"code": {"type": "string"}},
+                    "required": ["code"],
+                },
+            },
+        }
+    ]
+
+
+def test_structured_tool_args_stream_to_provisional_card(monkeypatch):
+    """A large structured tool call must stream its arguments as tool_args events
+    to the provisional card (backlog that triggered the card, then each
+    fragment), while the executed call and the model's view stay exactly what the
+    accumulator built."""
+
+    code = "print('x')\n" + ("# pad\n" * 80)
+    args_json = json.dumps({"code": code})
+    call_id = "call_live_args"
+    split = _PROVISIONAL_ARGS_MIN_CHARS + 16
+    frag1, frag2, frag3 = (
+        args_json[:split],
+        args_json[split : split + 40],
+        args_json[split + 40 :],
+    )
+
+    def _tc_delta(fragment: str, with_header: bool) -> str:
+        entry: dict = {"index": 0, "function": {"arguments": fragment}}
+        if with_header:
+            entry.update({"id": call_id, "type": "function"})
+            entry["function"]["name"] = "python"
+        return _sse({"tool_calls": [entry]})
+
+    first_stream = [
+        _tc_delta(frag1, with_header = True),
+        _tc_delta(frag2, with_header = False),
+        _tc_delta(frag3, with_header = False),
+        _done(),
+    ]
+    second_stream = [_sse({"content": "Done."}), _done()]
+    payloads: list[dict] = []
+    backend = _make_backend(monkeypatch, [first_stream, second_stream], payloads)
+
+    executed: list[tuple[str, dict]] = []
+
+    def fake_execute_tool(name, arguments, **_kwargs):
+        executed.append((name, arguments))
+        return "ok"
+
+    monkeypatch.setattr("core.inference.tools.execute_tool", fake_execute_tool)
+
+    events = list(
+        backend.generate_chat_completion_with_tools(
+            messages = [{"role": "user", "content": "run it"}],
+            tools = _python_tool_schema(),
+            max_tool_iterations = 1,
+        )
+    )
+
+    starts = [e for e in events if e.get("type") == "tool_start"]
+    assert starts and starts[0]["tool_call_id"] == call_id
+
+    args_events = [e for e in events if e.get("type") == "tool_args"]
+    assert args_events, "no tool_args events were streamed"
+    assert all(e["tool_call_id"] == call_id for e in args_events)
+    # First event is the backlog, the rest raw fragments; together the args JSON.
+    assert args_events[0]["text"] == frag1
+    assert "".join(e["text"] for e in args_events) == args_json
+
+    # The streamed display path must not perturb execution or the model view.
+    assert executed == [("python", {"code": code})]
+    assistant_messages = [m for m in payloads[1]["messages"] if m.get("role") == "assistant"]
+    tc = assistant_messages[-1]["tool_calls"][0]
+    assert tc["id"] == call_id
+    # Controller re-serializes args (normalized JSON); parsed payload unchanged.
+    assert json.loads(tc["function"]["arguments"]) == {"code": code}
+
+
+def test_text_tool_call_streams_args_and_reconciles_card(monkeypatch):
+    """A TEXT (XML) tool call must stream its raw call text as tool_args under the
+    id the stream-end parser assigns ("call_0"), so the provisional card and the
+    final tool_start reconcile."""
+
+    code = "print('hello')\n" + ("# filler\n" * 60)
+    call_json = json.dumps({"name": "python", "arguments": {"code": code}})
+    call_text = f"<tool_call>{call_json}</tool_call>"
+    chunks = [call_text[i : i + 48] for i in range(0, len(call_text), 48)]
+    first_stream = [_sse({"content": chunk}) for chunk in chunks] + [_done()]
+    second_stream = [_sse({"content": "Done."}), _done()]
+    payloads: list[dict] = []
+    backend = _make_backend(monkeypatch, [first_stream, second_stream], payloads)
+
+    executed: list[tuple[str, dict]] = []
+
+    def fake_execute_tool(name, arguments, **_kwargs):
+        executed.append((name, arguments))
+        return "ok"
+
+    monkeypatch.setattr("core.inference.tools.execute_tool", fake_execute_tool)
+
+    events = list(
+        backend.generate_chat_completion_with_tools(
+            messages = [{"role": "user", "content": "run it"}],
+            tools = _python_tool_schema(),
+            max_tool_iterations = 1,
+        )
+    )
+
+    starts = [e for e in events if e.get("type") == "tool_start"]
+    assert starts, "no tool_start emitted"
+    # Provisional card first (parser's first-call id), then the reconciling start.
+    assert starts[0]["tool_call_id"] == "call_0"
+    assert starts[0]["arguments"] == {}
+    assert starts[-1]["tool_call_id"] == "call_0"
+
+    args_events = [e for e in events if e.get("type") == "tool_args"]
+    assert args_events, "no tool_args events for the text call"
+    assert all(e["tool_call_id"] == "call_0" for e in args_events)
+    streamed = "".join(e["text"] for e in args_events)
+    # Streamed text is the drained call (display only); it must never leak into
+    # content events.
+    assert '"name": "python"' in streamed
+    assert executed == [("python", {"code": code})]
+    content_events = [e for e in events if e.get("type") == "content"]
+    assert not any("<tool_call>" in e["text"] for e in content_events)
+
+
+def test_ordinary_json_answer_streams_no_tool_args(monkeypatch):
+    """A large ordinary JSON answer (no enabled tool name) must not spawn a
+    provisional card or tool_args events; it stays a normal content answer."""
+
+    answer = json.dumps({"result": "fine", "data": ["x" * 40] * 12, "note": "not a tool call"})
+    chunks = [answer[i : i + 64] for i in range(0, len(answer), 64)]
+    stream = [_sse({"content": chunk}) for chunk in chunks] + [_done()]
+    payloads: list[dict] = []
+    backend = _make_backend(monkeypatch, [stream], payloads)
+
+    events = list(
+        backend.generate_chat_completion_with_tools(
+            messages = [{"role": "user", "content": "give me json"}],
+            tools = _python_tool_schema(),
+            max_tool_iterations = 1,
+        )
+    )
+
+    assert not [e for e in events if e.get("type") == "tool_args"]
+    assert not [e for e in events if e.get("type") == "tool_start"]
+    content_events = [e for e in events if e.get("type") == "content"]
+    assert content_events and answer in content_events[-1]["text"]
+
+
+def test_provisional_text_card_closed_when_parse_fails(monkeypatch):
+    """A >=256-char enabled-name text sniff opens a provisional card; if the
+    drained text then fails to parse (auto-heal off, truncated call), the
+    DRAINING false-positive path must close the card with a tool_end instead of
+    leaving it spinning forever."""
+
+    # Truncated mid-arguments and never closed: unparseable without healing.
+    call_text = '<tool_call>{"name": "python", "arguments": {"code": "' + "x" * (
+        _PROVISIONAL_ARGS_MIN_CHARS + 64
+    )
+    chunks = [call_text[i : i + 48] for i in range(0, len(call_text), 48)]
+    stream = [_sse({"content": chunk}) for chunk in chunks] + [_done()]
+    payloads: list[dict] = []
+    backend = _make_backend(monkeypatch, [stream], payloads)
+
+    executed: list[tuple[str, dict]] = []
+
+    def fake_execute_tool(name, arguments, **_kwargs):
+        executed.append((name, arguments))
+        return "ok"
+
+    monkeypatch.setattr("core.inference.tools.execute_tool", fake_execute_tool)
+
+    events = list(
+        backend.generate_chat_completion_with_tools(
+            messages = [{"role": "user", "content": "run it"}],
+            tools = _python_tool_schema(),
+            max_tool_iterations = 1,
+            auto_heal_tool_calls = False,
+        )
+    )
+
+    starts = [e for e in events if e.get("type") == "tool_start"]
+    ends = [e for e in events if e.get("type") == "tool_end"]
+    assert starts and starts[0]["tool_call_id"] == "call_0"
+    assert executed == []  # nothing parsed, nothing ran
+    assert ends, "provisional card left dangling (no tool_end)"
+    assert ends[-1]["tool_call_id"] == "call_0"
diff --git a/studio/backend/tests/test_sandbox_sitecustomize.py b/studio/backend/tests/test_sandbox_sitecustomize.py
new file mode 100644
index 0000000000..3ac427f9f1
--- /dev/null
+++ b/studio/backend/tests/test_sandbox_sitecustomize.py
@@ -0,0 +1,522 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Hermetic tests for the sandbox sitecustomize path-remap shim.
+
+The shim (``core/inference/sandbox_site/sitecustomize.py``) runs at interpreter
+startup inside every sandboxed tool subprocess and remaps ChatGPT
+code-interpreter habit paths (``/mnt/data`` etc.) onto the per-conversation
+working directory. Importing it calls ``_install()``, which monkeypatches
+``builtins.open`` / ``io.open`` / ``os.makedirs`` / ``os.mkdir`` /
+``pathlib.Path.mkdir`` process-wide, so these tests
+load it into a throwaway module and restore those globals immediately, then
+exercise the pure ``_remap()`` function directly -- no subprocess, and no real
+``/mnt`` or ``/tmp`` writes. The mkdir test keeps the patch installed under a
+``chdir`` into ``tmp_path`` so the only real writes land in that temp dir.
+"""
+
+from __future__ import annotations
+
+import builtins
+import importlib.util
+import io
+import os
+import pathlib
+from pathlib import Path
+
+import pytest
+
+_SHIM = (
+    Path(__file__).resolve().parent.parent
+    / "core"
+    / "inference"
+    / "sandbox_site"
+    / "sitecustomize.py"
+)
+
+
+def _save_patch_targets():
+    """Snapshot every global the shim patches, so tests can restore them.
+
+    On Python < 3.11 the shim also repoints ``pathlib._NormalAccessor.open``
+    (pathlib captured the original io.open at import there); the accessor is
+    absent on 3.11+, so the snapshot skips it.
+    """
+    accessor = getattr(pathlib, "_NormalAccessor", None)
+    return (
+        (builtins.open, io.open, os.open, os.makedirs, os.mkdir, pathlib.Path.mkdir),
+        accessor,
+        accessor.open if accessor is not None else None,
+    )
+
+
+def _restore_patch_targets(saved):
+    """Undo _save_patch_targets so the test process stays clean."""
+    globals_tuple, accessor, accessor_open = saved
+    (builtins.open, io.open, os.open, os.makedirs, os.mkdir, pathlib.Path.mkdir) = globals_tuple
+    if accessor is not None:
+        accessor.open = accessor_open
+
+
+def _load_shim():
+    """Import the shim without leaving its open()/mkdir patches installed."""
+    saved = _save_patch_targets()
+    spec = importlib.util.spec_from_file_location("_sandbox_sitecustomize_under_test", _SHIM)
+    mod = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(mod)  # runs _install(), patching the globals
+    finally:
+        # Undo the process-wide patch so the test process stays clean.
+        _restore_patch_targets(saved)
+    mod._notified = True  # silence the one-shot stderr notice in tests
+    return mod
+
+
+def test_always_remap_prefixes_map_into_cwd(monkeypatch, tmp_path):
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    assert mod._remap("/mnt/data/out.txt") == os.path.join(cwd, "out.txt")
+    assert mod._remap("/mnt/data") == cwd
+    # Unrelated absolute and relative paths pass straight through.
+    assert mod._remap("/etc/passwd") == "/etc/passwd"
+    assert mod._remap("relative.txt") == "relative.txt"
+
+
+def test_prefix_remap_contains_parent_traversal_inside_cwd(monkeypatch, tmp_path):
+    # A hallucinated habit path can carry '..' in its suffix. The remapped target
+    # must stay under the per-conversation CWD, never climbing into a sibling
+    # session's directory: '..' components are dropped, the rest of the subpath kept.
+    mod = _load_shim()
+    workdir = tmp_path / "session_current" / "work"
+    workdir.mkdir(parents = True)
+    monkeypatch.chdir(workdir)
+    cwd = os.getcwd()
+
+    for escaping in (
+        "/mnt/data/../other_session/file",
+        "/mnt/data/../../secrets.txt",
+        "/mnt/data/a/../../b/c.txt",
+        "/mnt/data/./sub/./x.txt",
+    ):
+        mapped = mod._remap(escaping)
+        # Never escapes the CWD subtree.
+        assert mapped == cwd or mapped.startswith(cwd + os.sep), (escaping, mapped)
+        assert os.path.realpath(mapped).startswith(os.path.realpath(cwd))
+    # '../other_session/file' collapses to CWD/other_session/file.
+    assert mod._remap("/mnt/data/../other_session/file") == os.path.join(
+        cwd, "other_session", "file"
+    )
+    # A bare '/mnt/data/..' with nothing left maps onto the CWD itself.
+    assert mod._remap("/mnt/data/..") == cwd
+
+
+def test_write_fallback_refuses_dotdot_basename(monkeypatch, tmp_path):
+    # basename('/no/such/tree/..') == '..'; joining that onto the CWD would target
+    # its parent (outside the sandbox). The fallback must refuse such non-filename
+    # basenames and return the path unchanged so the real open raises.
+    mod = _load_shim()
+    workdir = tmp_path / "work"
+    workdir.mkdir()
+    monkeypatch.chdir(workdir)
+    for escaping in ("/no/such/tree/..", "/no/such/tree/.", "/no/such/tree/"):
+        assert mod._remap_open(escaping, "w") == escaping
+
+
+def test_write_fallback_remaps_hallucinated_absolute_path(monkeypatch, tmp_path):
+    # Models invent absolute paths from their CWD (e.g. /home/ubuntu/Sandbox/x.html),
+    # which prefix lists cannot enumerate. A write/create-mode open on an absolute
+    # path outside the CWD whose parent is missing is redirected to the basename in the CWD.
+    mod = _load_shim()
+    workdir = tmp_path / "workdir"
+    workdir.mkdir()
+    monkeypatch.chdir(workdir)
+    cwd = os.getcwd()
+    hallucinated = "/home/ubuntu/Sandbox/flappy_bird.html"
+    for mode in ("w", "a", "x", "w+"):
+        assert mod._remap_open(hallucinated, mode) == os.path.join(cwd, "flappy_bird.html")
+    # A nested missing tree collapses to just the basename in the CWD.
+    assert mod._remap_open("/no/such/tree/report.txt", "w") == os.path.join(cwd, "report.txt")
+
+
+def test_write_fallback_never_touches_read_modes(monkeypatch, tmp_path):
+    # Reading a real (or genuinely missing) file must succeed/fail truthfully --
+    # the fallback is write-only.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    for mode in ("r", "rb", "r+"):
+        assert mod._remap_open("/etc/definitely_missing_xyz.conf", mode) == (
+            "/etc/definitely_missing_xyz.conf"
+        )
+
+
+def test_write_fallback_passes_through_existing_external_dir(monkeypatch, tmp_path):
+    # A write to an absolute path whose parent dir exists is a deliberate, working
+    # target and must NOT be redirected.
+    mod = _load_shim()
+    external = tmp_path / "external"
+    external.mkdir()
+    workdir = tmp_path / "workdir"
+    workdir.mkdir()
+    monkeypatch.chdir(workdir)
+    target = str(external / "out.txt")
+    assert mod._remap_open(target, "w") is target
+
+
+def test_write_fallback_never_clobbers_same_basename(monkeypatch, tmp_path):
+    # A same-named CWD file is an unrelated persistent conversation file.
+    # Redirecting an invented absolute path (missing parent) onto it would clobber
+    # data the model never asked to touch, so the fallback refuses on collision for
+    # every create mode: it returns the original path and the real open() raises.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+
+    existing = tmp_path / "report.txt"
+    existing.write_text("KEEP-ME")
+
+    requested = "/definitely_missing_parent_7083/report.txt"
+    for mode in ("w", "a", "x", "w+", "a+"):
+        # Refused: returns the original absolute path unchanged (no redirect).
+        assert mod._remap_open(requested, mode) == requested
+
+    # And opening the refused path really does raise, leaving the file intact.
+    with pytest.raises(FileNotFoundError):
+        open(mod._remap_open(requested, "w"), "w")
+    assert existing.read_text() == "KEEP-ME"
+
+    # No collision -> still healed into the working directory as before.
+    fresh = "/definitely_missing_parent_7083/brand_new.txt"
+    assert mod._remap_open(fresh, "w") == os.path.join(os.getcwd(), "brand_new.txt")
+
+
+def test_write_fallback_reserves_same_target_on_repeated_writes(monkeypatch, tmp_path):
+    # Iterative overwrite of the SAME invented path must keep landing on the CWD
+    # target the fallback first healed it to. Once ./app.html exists, a naive
+    # anti-clobber guard would return the original (parent-missing) path and every
+    # regenerate would raise; the fallback must recognise its own prior remap and re-serve it.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    invented = "/home/ubuntu/Sandbox/app.html"
+    target = os.path.join(cwd, "app.html")
+
+    # First write: healed into the CWD, and create the file so the collision guard
+    # would trigger on the next call without the fix.
+    assert mod._remap_open(invented, "w") == target
+    with open(mod._remap_open(invented, "w"), "w") as fh:
+        fh.write("v1")
+
+    # Repeated overwrites of the same invented path stay on the same target.
+    for _ in range(3):
+        assert mod._remap_open(invented, "w") == target
+    with open(mod._remap_open(invented, "w"), "w") as fh:
+        fh.write("v2")
+    assert Path(target).read_text() == "v2"
+
+    # A DIFFERENT invented source colliding on basename is still refused, so it can
+    # never clobber the artifact the first path owns.
+    other = "/opt/other/app.html"
+    assert mod._remap_open(other, "w") == other
+
+
+def test_write_fallback_reserves_healed_target_across_separate_runs(monkeypatch, tmp_path):
+    # Each tool call is a FRESH subprocess, so the in-process remap map is empty on
+    # the next run while the healed file persists in the working directory. A second
+    # run overwriting the SAME invented path (whose healed basename now exists) must
+    # still re-serve that target via the on-disk sidecar, else the model could never
+    # overwrite last turn's artifact. Each _load_shim() simulates a brand-new interpreter.
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    invented = "/home/ubuntu/Sandbox/app.html"
+    target = os.path.join(cwd, "app.html")
+
+    # Run 1: heal the invented path, create the file, persist source->target to the sidecar.
+    run1 = _load_shim()
+    assert run1._remap_open(invented, "w") == target
+    with open(run1._remap_open(invented, "w"), "w") as fh:
+        fh.write("v1")
+
+    # Run 2: brand-new interpreter, nothing in memory -- still recognises its prior
+    # heal from the sidecar and re-serves it, even though ./app.html now exists
+    # (which without the sidecar would trip the anti-clobber guard and raise).
+    run2 = _load_shim()
+    assert run2._remapped_writes == {}
+    assert run2._remap_open(invented, "w") == target
+    with open(run2._remap_open(invented, "w"), "w") as fh:
+        fh.write("v2")
+    assert Path(target).read_text() == "v2"
+
+    # A DIFFERENT invented source colliding only on basename is still refused across
+    # runs: the sidecar records solely the source it healed, so an unrelated path
+    # can never adopt/clobber the artifact.
+    other = "/opt/other/app.html"
+    assert run2._remap_open(other, "w") == other
+
+    # A foreign CWD file (created directly, never healed) stays protected in a later
+    # run from an invented path sharing its basename.
+    (tmp_path / "notes.txt").write_text("KEEP-ME")
+    run3 = _load_shim()
+    assert run3._remap_open("/some/missing/notes.txt", "w") == "/some/missing/notes.txt"
+    with pytest.raises(FileNotFoundError):
+        open(run3._remap_open("/some/missing/notes.txt", "w"), "w")
+    assert (tmp_path / "notes.txt").read_text() == "KEEP-ME"
+
+
+@pytest.mark.parametrize("mode", ["r+", "rb+"])
+def test_read_update_modes_never_redirected_even_with_missing_parent(monkeypatch, tmp_path, mode):
+    # r+ / rb+ REQUIRE the target to exist and never create; a "+" must not qualify
+    # as creation, or a missing absolute path would be redirected onto a same-basename
+    # workspace file and corrupt it. The parent is missing, so only the mode predicate
+    # protects the victim.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+
+    victim = tmp_path / "victim.txt"
+    victim.write_text("original")
+
+    requested = "/definitely_missing_parent_xyz/victim.txt"
+    assert mod._remap_open(requested, mode) == requested
+    with pytest.raises(FileNotFoundError):
+        open(mod._remap_open(requested, mode), mode)
+    assert victim.read_text() == "original"
+
+
+def test_existing_convention_prefix_is_not_shadowed(monkeypatch, tmp_path):
+    # A convention prefix (/mnt/data etc.) is remapped ONLY while absent. If a real
+    # host directory exists there it must pass through so its own filesystem semantics
+    # apply: a real read succeeds, and a missing file under it is created there by a
+    # write, never shadowed by a CWD file.
+    mod = _load_shim()
+    external = tmp_path / "real_prefix"
+    external.mkdir()
+    (external / "data.txt").write_text("real external content")
+
+    workdir = tmp_path / "conversation"
+    workdir.mkdir()
+    monkeypatch.chdir(workdir)
+    monkeypatch.setattr(mod, "_PREFIXES", (str(external),))
+    monkeypatch.setattr(mod, "_CONDITIONAL_PREFIXES", ())
+
+    target = str(external / "data.txt")
+    # Prefix exists -> pass through for read and write.
+    assert mod._remap(target) == target
+    assert mod._remap_open(target, "r") == target
+    assert mod._remap_open(target, "w") == target
+    # A missing file under the EXISTING real prefix is left alone (parent exists),
+    # so the real directory creates it -- not a CWD shadow.
+    missing = str(external / "new.txt")
+    assert mod._remap_open(missing, "w") == missing
+
+    # Remove the prefix directory -> healing resumes (absent prefix).
+    (external / "data.txt").unlink()
+    external.rmdir()
+    assert mod._remap(target) == os.path.join(os.getcwd(), "data.txt")
+
+
+def test_os_open_and_path_touch_remap_convention_path(monkeypatch, tmp_path):
+    # Path.touch() and other low-level creators go through os.open, not builtins/io.open.
+    # Keep the shim's patches installed under a chdir into tmp_path so os.open is
+    # patched, and confirm a convention path is healed into the CWD instead of raising.
+    saved = _save_patch_targets()
+    spec = importlib.util.spec_from_file_location("_sandbox_sitecustomize_osopen", _SHIM)
+    mod = importlib.util.module_from_spec(spec)
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    try:
+        spec.loader.exec_module(mod)  # installs the os.open patch
+        mod._notified = True
+        pathlib.Path("/mnt/data/touched.txt").touch()
+        assert os.path.isfile(os.path.join(cwd, "touched.txt"))
+        # Direct os.open with create flags is healed too.
+        fd = os.open("/mnt/data/via_os_open.txt", os.O_CREAT | os.O_WRONLY, 0o600)
+        os.close(fd)
+        assert os.path.isfile(os.path.join(cwd, "via_os_open.txt"))
+    finally:
+        _restore_patch_targets(saved)
+
+
+def test_path_write_read_text_remap_convention_path(monkeypatch, tmp_path):
+    # Path.open / write_text / read_text route through io.open (3.11+) or the captured
+    # accessor open (< 3.11). Keep the patches installed under a chdir into tmp_path
+    # and confirm a convention path is healed into the CWD on every version. This is
+    # the hermetic guard for the 3.10 accessor path a plain io.open patch misses.
+    saved = _save_patch_targets()
+    spec = importlib.util.spec_from_file_location("_sandbox_sitecustomize_writetext", _SHIM)
+    mod = importlib.util.module_from_spec(spec)
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    try:
+        spec.loader.exec_module(mod)  # installs the io.open / accessor patch
+        mod._notified = True
+        pathlib.Path("/mnt/data/note.txt").write_text("pathlib remap")
+        assert os.path.isfile(os.path.join(cwd, "note.txt"))
+        # read_text goes through the same mapped path and sees what was written.
+        assert pathlib.Path("/mnt/data/note.txt").read_text() == "pathlib remap"
+        # A real absolute path passes through both patches untouched.
+        real = tmp_path / "real.txt"
+        pathlib.Path(str(real)).write_text("verbatim")
+        assert real.read_text() == "verbatim"
+    finally:
+        _restore_patch_targets(saved)
+
+
+def test_write_fallback_leaves_relative_and_bytes_paths(monkeypatch, tmp_path):
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    # Relative paths are already inside the CWD.
+    assert mod._remap_open("out.txt", "w") == "out.txt"
+    # Bytes paths are left untouched (prefix remap skips non-str).
+    assert mod._remap_open(b"/no/such/tree/x.bin", "w") == b"/no/such/tree/x.bin"
+
+
+def test_remap_open_still_applies_prefix_remaps(monkeypatch, tmp_path):
+    # The prefix remap runs first and preserves subpaths. A write heals onto the CWD
+    # unconditionally; the write-mode fallback is only the last resort.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    assert mod._remap_open("/mnt/data/sub/out.txt", "w") == os.path.join(cwd, "sub", "out.txt")
+    # A read whose mapped target does NOT exist keeps the original path: a missing
+    # input stays truthful, not silently redirected into the CWD.
+    assert mod._remap_open("/mnt/data/sub/out.txt", "r") == "/mnt/data/sub/out.txt"
+
+
+def test_prefix_read_heals_only_when_mapped_target_exists(monkeypatch, tmp_path):
+    # A convention-prefix READ must not redirect onto the CWD when the mapped target
+    # is absent -- that masks a genuine missing-input error and could serve an
+    # unrelated same-basename workdir file. It heals only when the mapped CWD target
+    # exists, so re-reading an artifact an earlier write produced still works.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+
+    # Mapped target absent: read keeps the original path (truthful miss).
+    assert mod._remap_open("/mnt/data/input.csv", "r") == "/mnt/data/input.csv"
+    with pytest.raises(FileNotFoundError):
+        open(mod._remap_open("/mnt/data/input.csv", "r"))
+
+    # r+ (never creates) behaves the same: no redirect while absent.
+    assert mod._remap_open("/mnt/data/input.csv", "r+") == "/mnt/data/input.csv"
+
+    # A write heals onto the CWD and creates the artifact...
+    mapped = mod._remap_open("/mnt/data/input.csv", "w")
+    assert mapped == os.path.join(cwd, "input.csv")
+    with open(mapped, "w") as fh:
+        fh.write("col\n1\n")
+
+    # ...and now a READ of the same convention path heals onto that existing artifact.
+    read_target = mod._remap_open("/mnt/data/input.csv", "r")
+    assert read_target == os.path.join(cwd, "input.csv")
+    with open(read_target) as fh:
+        assert fh.read() == "col\n1\n"
+
+
+def test_prefix_boundary_not_matched_by_similar_paths(monkeypatch, tmp_path):
+    # The prefix match is anchored on a segment boundary (prefix or prefix + '/'), so
+    # a sibling merely sharing the textual prefix must NOT be remapped: /workspace2
+    # is not /workspace, /mnt/database is not /mnt/data.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    for unrelated in ("/workspace2/file.txt", "/mnt/database/x", "/home/sandboxed/y"):
+        assert mod._remap(unrelated) == unrelated
+        # And through open() for a read too (no silent redirect).
+        assert mod._remap_open(unrelated, "r") == unrelated
+
+
+def test_tmp_outputs_is_a_conditional_prefix():
+    mod = _load_shim()
+    assert "/tmp/outputs" in mod._CONDITIONAL_PREFIXES
+    # NOT in the always-remap set: /tmp exists on the host, so an unconditional remap
+    # could shadow a real /tmp/outputs the user code made.
+    assert "/tmp/outputs" not in mod._PREFIXES
+
+
+def test_tmp_outputs_remapped_only_while_absent(monkeypatch, tmp_path):
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    # Point the conditional prefix at a real temp location so we can toggle its
+    # existence on disk instead of mocking os.path.exists.
+    cond = str(tmp_path / "cond_outputs")
+    monkeypatch.setattr(mod, "_CONDITIONAL_PREFIXES", (cond,))
+
+    # Absent: heal the habit path into the working directory (preserved/served).
+    assert not os.path.exists(cond)
+    assert mod._remap(cond + "/plot.png") == os.path.join(cwd, "plot.png")
+    assert mod._remap(cond) == cwd
+
+    # Present (the user's own code created it): pass through, never shadowed.
+    os.makedirs(cond)
+    assert mod._remap(cond + "/plot.png") == cond + "/plot.png"
+    assert mod._remap(cond) == cond
+
+
+def test_pathlib_mkdir_parents_remaps_convention_path(monkeypatch, tmp_path):
+    # `Path('/mnt/data').mkdir(parents=True, exist_ok=True)` is a stock setup line.
+    # pathlib drives it through os.mkdir per component and Path.is_dir()/os.stat on
+    # FileExistsError, so the shim must patch os.mkdir AND Path.mkdir for the whole
+    # parents/exist_ok dance to land in the CWD instead of raising. Keeps the mkdir
+    # patches installed under a chdir into tmp_path and restores them in finally.
+    saved = _save_patch_targets()
+    spec = importlib.util.spec_from_file_location("_sandbox_sitecustomize_mkdir", _SHIM)
+    mod = importlib.util.module_from_spec(spec)
+    monkeypatch.chdir(tmp_path)
+    cwd = os.getcwd()
+    try:
+        spec.loader.exec_module(mod)  # installs the os.mkdir / Path.mkdir patches
+        mod._notified = True
+        # Bare convention path maps onto the CWD, which already exists: exist_ok=True
+        # must be honoured against the mapped location, not raise.
+        pathlib.Path("/mnt/data").mkdir(parents = True, exist_ok = True)
+        # A nested convention path is created inside the CWD, parents and all.
+        pathlib.Path("/mnt/data/plots/run1").mkdir(parents = True, exist_ok = True)
+        assert os.path.isdir(os.path.join(cwd, "plots", "run1"))
+        # Idempotent: exist_ok is evaluated on the mapped path (which now exists),
+        # not the never-present /mnt/data.
+        pathlib.Path("/mnt/data/plots/run1").mkdir(parents = True, exist_ok = True)
+
+        # Passthrough: real paths are created verbatim through both patches,
+        # never remapped into the CWD.
+        real_dir = tmp_path / "real_via_path"
+        pathlib.Path(str(real_dir)).mkdir()
+        assert real_dir.is_dir()
+        real_os = tmp_path / "real_via_os"
+        os.mkdir(str(real_os))
+        assert real_os.is_dir()
+    finally:
+        _restore_patch_targets(saved)
+
+
+def test_read_of_missing_prefix_path_emits_no_notice(monkeypatch, tmp_path, capsys):
+    # A read of a missing convention path keeps the original path and must not spend
+    # the one-shot notice; a genuine remap afterward still notifies.
+    mod = _load_shim()
+    monkeypatch.chdir(tmp_path)
+    mod._notified = False  # re-arm the one-shot notice for this test
+    # Read of a missing prefixed path: original kept, no notice, flag unspent.
+    assert mod._remap_open("/mnt/data/missing.csv", "r") == "/mnt/data/missing.csv"
+    assert mod._notified is False
+    assert "does not exist" not in capsys.readouterr().err
+    # A committed write then heals and fires the notice exactly once.
+    assert mod._remap_open("/mnt/data/out.txt", "w") == os.path.join(os.getcwd(), "out.txt")
+    assert mod._notified is True
+    assert "/mnt/data does not exist in this sandbox" in capsys.readouterr().err
+
+
+def test_os_open_trunc_without_creat_missing_stays_truthful(monkeypatch, tmp_path):
+    # O_TRUNC / O_APPEND without O_CREAT cannot create a missing file, so the shim
+    # treats them as a read: a missing convention path stays truthful (the error
+    # names the caller's path) and nothing is created in the CWD.
+    saved = _save_patch_targets()
+    spec = importlib.util.spec_from_file_location("_sandbox_sitecustomize_trunc", _SHIM)
+    mod = importlib.util.module_from_spec(spec)
+    monkeypatch.chdir(tmp_path)
+    try:
+        spec.loader.exec_module(mod)
+        mod._notified = True
+        with pytest.raises(FileNotFoundError) as exc:
+            os.open("/mnt/data/missing_xyz.bin", os.O_WRONLY | os.O_TRUNC)
+        assert exc.value.filename == "/mnt/data/missing_xyz.bin"
+        assert not os.path.exists(os.path.join(os.getcwd(), "missing_xyz.bin"))
+    finally:
+        _restore_patch_targets(saved)
diff --git a/studio/backend/tests/test_sandbox_tools.py b/studio/backend/tests/test_sandbox_tools.py
index 24b1da1772..2970b1a6bb 100644
--- a/studio/backend/tests/test_sandbox_tools.py
+++ b/studio/backend/tests/test_sandbox_tools.py
@@ -294,11 +294,16 @@ class TestSandboxEnvIsolation:
             "LANG",
             "TERM",
             "PYTHONIOENCODING",
+            "PYTHONPATH",
             "VIRTUAL_ENV",
             "SystemRoot",
         }
         extras = set(env.keys()) - allowed
         assert not extras, f"sandbox env added unexpected keys: {extras}"
+        # PYTHONPATH is whitelist-built, never inherited: only the sandbox
+        # sitecustomize shim dir (code-interpreter path remap).
+        assert env["PYTHONPATH"].endswith("sandbox_site")
+        assert "leak-me" not in env["PYTHONPATH"]
 
     def test_home_points_at_sandbox_workdir(self, tmp_path):
         from core.inference.tools import _build_safe_env
@@ -315,6 +320,23 @@ class TestSandboxEnvIsolation:
         env = _build_safe_env(str(tmp_path))
         assert env["TERM"] == "dumb"
 
+    def test_bypass_env_installs_sitecustomize_path_shim(self, tmp_path):
+        # Bypass mode must install the same /mnt/data path-remap shim as the safe
+        # env (finding 17), else /mnt/data writes work only in normal mode.
+        from core.inference.tools import _SANDBOX_SITE_DIR, _build_bypass_env
+        env = _build_bypass_env(str(tmp_path))
+        assert _SANDBOX_SITE_DIR in env["PYTHONPATH"].split(os.pathsep)
+
+    def test_bypass_env_prepends_shim_and_keeps_inherited_pythonpath(self, monkeypatch, tmp_path):
+        from core.inference.tools import _SANDBOX_SITE_DIR, _build_bypass_env
+
+        monkeypatch.setenv("PYTHONPATH", "/operator/libs")
+        env = _build_bypass_env(str(tmp_path))
+        parts = env["PYTHONPATH"].split(os.pathsep)
+        # Shim first so its open()/makedirs remap wins, operator entries kept.
+        assert parts[0] == _SANDBOX_SITE_DIR
+        assert "/operator/libs" in parts
+
 
 class TestSandboxCpuRlimitDefault:
     """Pin the default so a regression below 600s without opt-in is caught."""
diff --git a/studio/backend/tests/test_tool_output_streaming.py b/studio/backend/tests/test_tool_output_streaming.py
new file mode 100644
index 0000000000..28bd79cc6e
--- /dev/null
+++ b/studio/backend/tests/test_tool_output_streaming.py
@@ -0,0 +1,1234 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Live tool-output streaming and heartbeats for server-side tool execution.
+
+Covers three invariants:
+
+* ``stream_tool_execution`` yields incremental ``tool_output`` events and
+  ``heartbeat`` events while a tool blocks, and returns the tool's result
+  byte-identical to a direct call;
+* ``_python_exec`` / ``_bash_exec`` produce the same result string with and
+  without an ``output_callback`` (the final tool message the model sees is
+  untouched by streaming);
+* the GGUF agentic loop emits ``tool_output`` between ``tool_start`` and
+  ``tool_end`` and feeds the model the same ``role=tool`` message as before.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+import time
+from pathlib import Path
+
+import pytest
+
+_BACKEND_DIR = str(Path(__file__).resolve().parent.parent)
+if _BACKEND_DIR not in sys.path:
+    sys.path.insert(0, _BACKEND_DIR)
+_TESTS_DIR = str(Path(__file__).resolve().parent)
+if _TESTS_DIR not in sys.path:
+    sys.path.insert(0, _TESTS_DIR)
+
+from core.inference.tool_stream_exec import (
+    TOOL_OUTPUT_STREAM_MAX_CHARS,
+    stream_tool_execution,
+)
+from core.inference.tools import _bash_exec, _python_exec
+
+from test_llama_cpp_tool_loop import _done, _make_backend, _sse
+
+
+def _run_stream(invoke, **kwargs):
+    """Drive the wrapper generator; return (events, result)."""
+    gen = stream_tool_execution(invoke, **kwargs)
+    events = []
+    while True:
+        try:
+            events.append(next(gen))
+        except StopIteration as stop:
+            return events, stop.value
+
+
+# ── stream_tool_execution ────────────────────────────────────────
+
+
+def test_result_returned_verbatim_without_output():
+    events, result = _run_stream(
+        lambda _cb: "final result",
+        tool_name = "web_search",
+    )
+    assert result == "final result"
+    assert [e for e in events if e["type"] == "tool_output"] == []
+
+
+def test_incremental_output_streams_as_tool_output_events():
+    def tool(callback):
+        callback("line 1\n")
+        callback("line 2\n")
+        return "line 1\nline 2\n"
+
+    events, result = _run_stream(tool, tool_name = "python", tool_call_id = "call_1")
+    assert result == "line 1\nline 2\n"
+    outputs = [e for e in events if e["type"] == "tool_output"]
+    assert outputs, "expected tool_output events"
+    assert "".join(e["text"] for e in outputs) == "line 1\nline 2\n"
+    assert all(e["tool_name"] == "python" for e in outputs)
+    assert all(e["tool_call_id"] == "call_1" for e in outputs)
+
+
+def test_heartbeats_emitted_while_tool_blocks():
+    release = threading.Event()
+
+    def tool(_cb):
+        release.wait(timeout = 5)
+        return "done"
+
+    gen = stream_tool_execution(
+        tool,
+        tool_name = "web_search",
+        heartbeat_interval_s = 0.04,
+        poll_interval_s = 0.02,
+    )
+    events = []
+    result = None
+    try:
+        while True:
+            event = next(gen)
+            events.append(event)
+            if len([e for e in events if e["type"] == "heartbeat"]) >= 2:
+                release.set()
+    except StopIteration as stop:
+        result = stop.value
+    assert result == "done"
+    assert len([e for e in events if e["type"] == "heartbeat"]) >= 2
+
+
+def test_output_resets_heartbeat_pacing():
+    # A steady output stream means no heartbeats are needed.
+    def tool(callback):
+        for i in range(5):
+            callback(f"tick {i}\n")
+            time.sleep(0.01)
+        return "ok"
+
+    events, result = _run_stream(
+        tool,
+        tool_name = "python",
+        heartbeat_interval_s = 10.0,
+        poll_interval_s = 0.02,
+    )
+    assert result == "ok"
+    assert [e for e in events if e["type"] == "heartbeat"] == []
+
+
+def test_tool_exception_propagates_after_stream():
+    def tool(_cb):
+        raise RuntimeError("boom")
+
+    gen = stream_tool_execution(tool, tool_name = "python")
+    try:
+        while True:
+            next(gen)
+    except RuntimeError as exc:
+        assert str(exc) == "boom"
+    else:
+        raise AssertionError("expected RuntimeError")
+
+
+def test_output_before_worker_raises_is_preserved():
+    # Output streamed before the worker raises survives; the exception still propagates.
+    def tool(callback):
+        callback("partial before crash\n")
+        time.sleep(0.02)
+        raise RuntimeError("late boom")
+
+    gen = stream_tool_execution(tool, tool_name = "python", poll_interval_s = 0.01)
+    events = []
+    with pytest.raises(RuntimeError, match = "late boom"):
+        while True:
+            events.append(next(gen))
+    streamed = "".join(e["text"] for e in events if e["type"] == "tool_output")
+    assert "partial before crash" in streamed
+
+
+def test_generator_close_cancels_observing_tool():
+    # gen.close() (SSE client disconnect) sets the shared cancel_event, so a
+    # cancel-observing tool returns at once.
+    cancel_event = threading.Event()
+    started = threading.Event()
+    returned = threading.Event()
+
+    def tool(_cb):
+        started.set()
+        cancel_event.wait(timeout = 5)  # cancel-observing: unblocks on cancel
+        returned.set()
+        return "cancelled cleanly"
+
+    gen = stream_tool_execution(
+        tool,
+        tool_name = "web_search",
+        cancel_event = cancel_event,
+        heartbeat_interval_s = 0.02,
+        poll_interval_s = 0.01,
+    )
+    next(gen)  # prime the worker; returns a heartbeat while the tool blocks
+    assert started.wait(timeout = 2)
+    gen.close()  # GeneratorExit -> sets cancel_event, then bounded join
+    assert cancel_event.is_set()
+    assert returned.wait(timeout = 2)  # the tool actually observed cancellation
+
+
+def test_generator_close_is_bounded_for_cancel_ignoring_tool(monkeypatch):
+    # A tool that ignores cancel_event must not stall teardown: gen.close() waits
+    # at most the bounded join, not the tool's full runtime.
+    monkeypatch.setattr("core.inference.tool_stream_exec._WORKER_JOIN_TIMEOUT_S", 0.2)
+    release = threading.Event()
+
+    def tool(_cb):
+        # Ignores cancel_event; stands in for a web_search/MCP call that never polls it.
+        release.wait(timeout = 30)
+        return "slow"
+
+    gen = stream_tool_execution(
+        tool,
+        tool_name = "web_search",
+        cancel_event = threading.Event(),
+        heartbeat_interval_s = 0.02,
+        poll_interval_s = 0.01,
+    )
+    next(gen)
+    started = time.monotonic()
+    gen.close()
+    elapsed = time.monotonic() - started
+    release.set()  # let the daemon worker finish so no sleeper lingers
+    assert elapsed < 2.0  # bounded by _WORKER_JOIN_TIMEOUT_S, not the 30s tool
+
+
+def test_cancel_event_not_set_on_clean_finish():
+    # cancel_event is shared across a turn; a clean finish must leave it unset so
+    # the next tool in the same turn is not aborted.
+    cancel_event = threading.Event()
+
+    def tool(_cb):
+        return "ok"
+
+    events, result = _run_stream(
+        tool,
+        tool_name = "python",
+        cancel_event = cancel_event,
+    )
+    assert result == "ok"
+    assert not cancel_event.is_set()
+
+
+def test_no_worker_thread_leak_under_repeated_close(monkeypatch):
+    # Repeated start-then-close must not leak worker threads: each cancel-observing
+    # worker exits once close() signals it.
+    monkeypatch.setattr("core.inference.tool_stream_exec._WORKER_JOIN_TIMEOUT_S", 0.2)
+
+    def _live_tool_workers():
+        return [t for t in threading.enumerate() if t.name.startswith("tool-exec-")]
+
+    for _ in range(50):  # let workers from earlier tests drain
+        if not _live_tool_workers():
+            break
+        time.sleep(0.02)
+    baseline = len(_live_tool_workers())
+
+    for _ in range(60):
+        cancel_event = threading.Event()
+
+        def tool(_cb, _ev = cancel_event):
+            _ev.wait(timeout = 5)
+            return "done"
+
+        gen = stream_tool_execution(
+            tool,
+            tool_name = "soak",
+            cancel_event = cancel_event,
+            heartbeat_interval_s = 0.02,
+            poll_interval_s = 0.01,
+        )
+        next(gen)
+        gen.close()  # sets cancel_event -> tool returns -> worker exits
+
+    for _ in range(100):
+        if len(_live_tool_workers()) <= baseline:
+            break
+        time.sleep(0.02)
+    assert len(_live_tool_workers()) <= baseline
+
+
+def test_streamed_output_is_capped_but_result_is_not():
+    big = "x" * (TOOL_OUTPUT_STREAM_MAX_CHARS + 5000)
+
+    def tool(callback):
+        callback(big)
+        return big
+
+    events, result = _run_stream(tool, tool_name = "python")
+    assert result == big  # final result untouched by the stream cap
+    streamed = "".join(e["text"] for e in events if e["type"] == "tool_output")
+    assert len(streamed) < len(big)
+    assert "further live output not streamed" in streamed
+
+
+def test_heartbeats_continue_while_capped_output_flows():
+    # After the cap, discarded chunks must not starve the keepalive: a chatty tool
+    # keeps the queue non-empty, so without the fix no heartbeat fires and the SSE
+    # stream stays silent past proxy idle timeouts.
+    release = threading.Event()
+
+    def tool(callback):
+        callback("x" * (TOOL_OUTPUT_STREAM_MAX_CHARS + 10))  # trip the cap
+        while not release.is_set():
+            callback("post-cap spam")
+            time.sleep(0.005)
+        return "done"
+
+    # Watchdog: on regressed code next(gen) blocks forever while spam flows; the
+    # timer ends the tool, turning that hang into a clean assertion failure.
+    watchdog = threading.Timer(8.0, release.set)
+    watchdog.start()
+    gen = stream_tool_execution(
+        tool,
+        tool_name = "python",
+        heartbeat_interval_s = 0.04,
+        poll_interval_s = 0.02,
+    )
+    events = []
+    result = None
+    try:
+        while True:
+            event = next(gen)
+            events.append(event)
+            if len([e for e in events if e["type"] == "heartbeat"]) >= 2:
+                release.set()
+    except StopIteration as stop:
+        result = stop.value
+    finally:
+        release.set()
+        watchdog.cancel()
+    assert result == "done"
+    assert len([e for e in events if e["type"] == "heartbeat"]) >= 2
+    streamed = "".join(e["text"] for e in events if e["type"] == "tool_output")
+    assert "further live output not streamed" in streamed
+    assert "post-cap spam" not in streamed  # cap still enforced
+
+
+def test_drain_queue_bounds_the_over_cap_batch():
+    # _drain_queue stops concatenating once the cap is first exceeded and discards
+    # the rest in place, so a chatty tool's huge backlog never defeats the memory ceiling.
+    import queue as _queue
+
+    from core.inference.tool_stream_exec import _drain_queue
+
+    q: _queue.Queue = _queue.Queue()
+    sentinel = object()
+    chunk = "z" * 1000
+    for _ in range(5000):  # 5 MB queued ahead of the drain
+        q.put(chunk)
+    q.put(sentinel)
+    text, hit_sentinel = _drain_queue(q, sentinel, max_chars = 100)
+    assert hit_sentinel is True
+    # At most cap + one chunk is joined, not the full 5 MB backlog.
+    assert len(text) <= 100 + len(chunk)
+    assert q.empty()  # surplus still drained so completion is detected
+
+
+def test_drain_queue_does_not_materialize_surplus_crossing_chunk():
+    # The single chunk that first crosses the cap must not be materialized in full
+    # (a tool can emit one multi-megabyte line). Keep just one char past the budget
+    # to preserve the overflow signal and byte-identical truncation, even when the
+    # budget is already met (max_chars <= 0).
+    import queue as _queue
+
+    from core.inference.tool_stream_exec import _drain_queue
+
+    sentinel = object()
+    huge = "z" * 1_000_000
+
+    # Budget already met (non-positive): keep one char, a true prefix.
+    for cap in (0, -500):
+        q: _queue.Queue = _queue.Queue()
+        q.put(huge)
+        q.put("more")
+        q.put(sentinel)
+        text, hit_sentinel = _drain_queue(q, sentinel, max_chars = cap)
+        assert hit_sentinel is True
+        assert len(text) == 1
+        assert huge.startswith(text)
+        assert q.empty()
+
+    # Positive cap crossed by one huge chunk: bounded to cap + 1, prefix kept.
+    q = _queue.Queue()
+    q.put(huge)
+    q.put(sentinel)
+    text, hit_sentinel = _drain_queue(q, sentinel, max_chars = 100)
+    assert len(text) == 101
+    assert text == huge[:101]
+
+
+def test_drain_queue_unbounded_joins_everything():
+    # Without a cap the join is complete and ordered (the sub-cap path streams
+    # every chunk verbatim on this).
+    import queue as _queue
+
+    from core.inference.tool_stream_exec import _drain_queue
+
+    q: _queue.Queue = _queue.Queue()
+    sentinel = object()
+    for i in range(3):
+        q.put(f"c{i}")
+    q.put(sentinel)
+    text, hit_sentinel = _drain_queue(q, sentinel, max_chars = None)
+    assert hit_sentinel is True
+    assert text == "c0c1c2"
+
+
+def test_over_cap_crossing_batch_streams_capped_output():
+    # End-to-end: a burst crossing the cap in one drain still yields a capped live
+    # stream and an untouched final result.
+    chunk = "z" * 1000
+
+    def tool(callback):
+        for _ in range(3000):  # ~3 MB, well past the cap, in one burst
+            callback(chunk)
+        return "final"
+
+    events, result = _run_stream(tool, tool_name = "python")
+    assert result == "final"
+    streamed = "".join(e["text"] for e in events if e["type"] == "tool_output")
+    assert len(streamed) <= TOOL_OUTPUT_STREAM_MAX_CHARS + len(
+        "\n... (further live output not streamed)\n"
+    )
+    assert "further live output not streamed" in streamed
+
+
+# ── python / terminal executors ──────────────────────────────────
+
+_PY_CODE = "for i in range(5):\n    print('row', i)\n"
+
+
+def test_python_exec_result_identical_with_streaming():
+    baseline = _python_exec(_PY_CODE, timeout = 60)
+    chunks: list[str] = []
+    streamed = _python_exec(_PY_CODE, timeout = 60, output_callback = chunks.append)
+    assert streamed == baseline
+    assert "".join(chunks) == "".join(f"row {i}\n" for i in range(5))
+
+
+def test_python_exec_streams_lines_incrementally():
+    # The first of two sleep-separated prints must reach the callback well before exit.
+    code = (
+        "import time\n"
+        "print('first', flush=True)\n"
+        "time.sleep(1.0)\n"
+        "print('second', flush=True)\n"
+    )
+    first_seen_at: list[float] = []
+
+    def on_chunk(_text: str) -> None:
+        if not first_seen_at:
+            first_seen_at.append(time.monotonic())
+
+    started = time.monotonic()
+    result = _python_exec(code, timeout = 60, output_callback = on_chunk)
+    finished = time.monotonic()
+    assert "first" in result and "second" in result
+    assert first_seen_at, "callback never invoked"
+    # First line arrived before the sleep completed (margin for slow interpreter start).
+    assert first_seen_at[0] - started < finished - started - 0.5
+
+
+def test_python_exec_unflushed_print_streams_live_and_result_identical():
+    # A bare print() WITHOUT flush=True then a sleep. -u forces the child's stdout
+    # unbuffered so the line reaches the callback before exit (else CPython
+    # block-buffers the pipe and the live pane stays empty). -u changes timing only,
+    # so the joined result stays byte-identical to the non-streaming run.
+    code = (
+        "import time\n"
+        "print('progress')\n"  # no flush=True
+        "time.sleep(1.0)\n"
+        "print('done')\n"
+    )
+    first_seen_at: list[float] = []
+
+    def on_chunk(_text: str) -> None:
+        if not first_seen_at:
+            first_seen_at.append(time.monotonic())
+
+    baseline = _python_exec(code, timeout = 60)
+    started = time.monotonic()
+    streamed = _python_exec(code, timeout = 60, output_callback = on_chunk)
+    finished = time.monotonic()
+    assert streamed == baseline
+    assert "progress" in streamed and "done" in streamed
+    assert first_seen_at, "callback never invoked for unflushed print"
+    # Unflushed line arrived before the sleep finished: streamed live, not at exit.
+    assert first_seen_at[0] - started < finished - started - 0.5
+
+
+def test_python_exec_error_exit_identical_with_streaming():
+    code = "print('before')\nraise SystemExit(3)\n"
+    baseline = _python_exec(code, timeout = 60)
+    streamed = _python_exec(code, timeout = 60, output_callback = lambda _t: None)
+    assert streamed == baseline
+    assert streamed.startswith("Exit code 3:")
+
+
+def test_python_exec_timeout_message_identical_with_streaming():
+    code = "import time\ntime.sleep(30)\n"
+    baseline = _python_exec(code, timeout = 1)
+    streamed = _python_exec(code, timeout = 1, output_callback = lambda _t: None)
+    assert streamed == baseline == "Execution timed out after 1 seconds."
+
+
+def test_python_exec_callback_errors_do_not_break_execution():
+    def bad_callback(_text: str) -> None:
+        raise ValueError("observer bug")
+
+    result = _python_exec("print('ok')", timeout = 60, output_callback = bad_callback)
+    assert result.strip() == "ok"
+
+
+def test_bash_exec_result_identical_with_streaming():
+    command = "echo one; echo two"
+    baseline = _bash_exec(command, timeout = 60)
+    chunks: list[str] = []
+    streamed = _bash_exec(command, timeout = 60, output_callback = chunks.append)
+    assert streamed == baseline
+    assert "".join(chunks) == "one\ntwo\n"
+
+
+def test_bash_exec_invalid_utf8_identical_with_streaming():
+    # Invalid UTF-8 must not kill either path: the pipe decodes with
+    # errors="replace", so the streaming reader thread cannot die on the
+    # UnicodeDecodeError readline raises, and both paths return the same replaced text.
+    command = "printf 'ok\\377bad\\n'"  # \377 = 0xFF, invalid UTF-8
+    baseline = _bash_exec(command, timeout = 60)
+    chunks: list[str] = []
+    streamed = _bash_exec(command, timeout = 60, output_callback = chunks.append)
+    assert streamed == baseline
+    assert not baseline.startswith("Execution error")
+    assert "ok" in baseline and "bad" in baseline
+    assert "�" in baseline  # replacement character, not a crash
+    assert "".join(chunks) == "ok�bad\n"
+
+
+def test_bash_exec_unlimited_timeout_waits_for_grandchild_output():
+    # A background grandchild holds the pipe open past the shell's exit and writes
+    # ~7s later. With timeout=None the drain must wait for EOF like
+    # communicate(timeout=None), so the late output is included.
+    command = "( sleep 7; echo late-grandchild-output ) & echo parent-done"
+    chunks: list[str] = []
+    result = _bash_exec(command, timeout = None, output_callback = chunks.append)
+    assert "parent-done" in result
+    assert "late-grandchild-output" in result
+    assert "late-grandchild-output" in "".join(chunks)
+
+
+def test_bash_exec_finite_timeout_kills_grandchild_holding_stdout(tmp_path):
+    # A backgrounded grandchild holds the pipe open past the finite timeout, then
+    # would write a sentinel. The parent shell has already exited, so killing only
+    # the reaped parent leaves the grandchild running; the drain must kill the
+    # process group captured before the wait so the grandchild never writes.
+    sentinel = tmp_path / "grandchild_ran"
+    command = f"( sleep 3; touch '{sentinel}' ) & echo parent-done"
+    result = _bash_exec(command, timeout = 1, output_callback = lambda _t: None)
+    assert "timed out" in result
+    time.sleep(4.0)  # past the grandchild's 3s sleep
+    assert not sentinel.exists(), "grandchild survived the timeout process-group kill"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_bash_exec_nonstreaming_timeout_kills_grandchild(tmp_path):
+    # The NON-streaming path (communicate() + _kill_process_tree) short-circuits
+    # once the reaped leader has exited, so a stdout-holding grandchild survives
+    # unless the group captured right after spawn is killed too. Must match the
+    # streaming path's exited-leader handling.
+    sentinel = tmp_path / "grandchild_ran"
+    command = f"( sleep 3; touch '{sentinel}' ) & echo parent-done"
+    result = _bash_exec(command, timeout = 1)  # no output_callback -> communicate path
+    assert "timed out" in result
+    time.sleep(4.0)
+    assert not sentinel.exists(), "non-streaming timeout leaked a stdout-holding grandchild"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_python_exec_nonstreaming_timeout_kills_grandchild(tmp_path):
+    sentinel = tmp_path / "grandchild_ran"
+    code = (
+        "import subprocess\n"
+        f"subprocess.Popen(['bash', '-c', \"sleep 3; touch '{sentinel}'\"])\n"
+        "print('parent-done')\n"
+        "import time; time.sleep(30)\n"
+    )
+    result = _python_exec(code, timeout = 1)  # no output_callback -> communicate path
+    assert "timed out" in result
+    time.sleep(4.0)
+    assert not sentinel.exists(), "non-streaming timeout leaked a stdout-holding grandchild"
+
+
+def test_drain_process_output_without_posix_process_group_apis(monkeypatch):
+    # On Windows os.getpgid / os.killpg are absent; _drain_process_output must not
+    # raise AttributeError before reading the child's output. Removing the APIs and
+    # flipping os.name: the child still runs and is captured, only the group kill is skipped.
+    import subprocess as _sp
+
+    from core.inference.tools import _drain_process_output
+
+    monkeypatch.delattr(os, "getpgid", raising = False)
+    monkeypatch.delattr(os, "killpg", raising = False)
+    monkeypatch.setattr(os, "name", "nt")
+
+    proc = _sp.Popen(
+        [sys.executable, "-c", "print('ok-no-pgid')"],
+        stdout = _sp.PIPE,
+        stderr = _sp.STDOUT,
+        text = True,
+    )
+    output, timed_out = _drain_process_output(proc, 10, lambda _t: None)
+    assert not timed_out
+    assert "ok-no-pgid" in output
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_captured_group_survives_fast_leader_reap(tmp_path):
+    # Capture the group after spawn, reap the leader first (as a polling cancel
+    # watcher would), then drain: the pre-captured pgid must still reap the
+    # stdout-holding grandchild even though os.getpgid(pid) would now fail.
+    import subprocess as _sp
+
+    from core.inference.tools import _capture_process_group, _drain_process_output
+
+    sentinel = tmp_path / "grandchild_ran"
+    proc = _sp.Popen(
+        ["bash", "-c", f"( sleep 3; touch '{sentinel}' ) & echo parent-done"],
+        stdout = _sp.PIPE,
+        stderr = _sp.STDOUT,
+        text = True,
+        preexec_fn = os.setsid,
+    )
+    pgid = _capture_process_group(proc)
+    assert pgid is not None
+    proc.wait()  # reap the leader before draining
+
+    output, timed_out = _drain_process_output(proc, 0.5, None, pgid = pgid)
+    assert timed_out
+    assert "parent-done" in output
+    time.sleep(4.0)
+    assert not sentinel.exists(), "pre-captured group failed to reap the grandchild"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_finite_drain_honors_cancel_after_leader_exit(tmp_path):
+    # Once the leader exits the cancel watcher (which loops on proc.poll()) is gone,
+    # so the finite-timeout drain itself must honor cancellation: a mid-drain
+    # cancel_event must break the drain promptly and kill the process group instead
+    # of draining a chatty grandchild for the whole large budget.
+    import subprocess as _sp
+    import threading as _th
+
+    from core.inference.tools import _capture_process_group, _drain_process_output
+
+    sentinel = tmp_path / "grandchild_late"
+    # Grandchild holds the pipe open, streams every 0.2s, and touches the sentinel
+    # only after 10s -- well past the cancel. The leader exits immediately, so the
+    # drain enters the finite branch with a live, chatty reader.
+    proc = _sp.Popen(
+        [
+            "bash",
+            "-c",
+            "( for i in $(seq 1 100); do echo tick-$i; sleep 0.2; done; "
+            f"touch '{sentinel}' ) & echo parent-done",
+        ],
+        stdout = _sp.PIPE,
+        stderr = _sp.STDOUT,
+        text = True,
+        preexec_fn = os.setsid,
+    )
+    pgid = _capture_process_group(proc)
+    assert pgid is not None
+    proc.wait()  # leader exits at once; the cancel watcher would now be gone
+
+    cancel_event = _th.Event()
+    _th.Timer(0.6, cancel_event.set).start()  # cancel shortly into the drain
+
+    started = time.monotonic()
+    # Large finite timeout (30s); without the cancel poll the drain keeps reading
+    # the grandchild until the pipe closes ~20s later.
+    output, timed_out = _drain_process_output(proc, 30, lambda _t: None, cancel_event, pgid = pgid)
+    elapsed = time.monotonic() - started
+    assert elapsed < 5.0, f"finite drain ignored cancel_event (took {elapsed:.1f}s)"
+    # Cancellation is not a timeout: the budget never elapsed.
+    assert not timed_out
+    assert "parent-done" in output
+    time.sleep(11.0)  # past the grandchild's 10s sentinel write
+    assert not sentinel.exists(), "cancel did not kill the stdout-holding grandchild group"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_streamed_wait_timeout_kills_grandchild_when_leader_reaped(tmp_path, monkeypatch):
+    # The proc.wait() timeout branch normally kills the group via _kill_process_tree.
+    # But the leader can exit before _kill_process_tree samples its pgid, which then
+    # short-circuits on the reaped leader and leaves a stdout-holding grandchild.
+    # Model that race with _kill_process_tree as a no-op; the captured-pgid kill in
+    # the timeout branch must still reap the grandchild, matching non-streaming.
+    import subprocess as _sp
+
+    from core.inference import tools as _tools_mod
+    from core.inference.tools import _capture_process_group, _drain_process_output
+
+    monkeypatch.setattr(_tools_mod, "_kill_process_tree", lambda proc: None)
+
+    sentinel = tmp_path / "grandchild_ran"
+    # Leader sleeps past the timeout so proc.wait() genuinely times out; a same-group
+    # grandchild holds stdout and would touch the sentinel unless the group is killed.
+    proc = _sp.Popen(
+        ["bash", "-c", f"( sleep 3; touch '{sentinel}' ) & sleep 30"],
+        stdout = _sp.PIPE,
+        stderr = _sp.STDOUT,
+        text = True,
+        preexec_fn = os.setsid,
+    )
+    pgid = _capture_process_group(proc)
+    assert pgid is not None
+
+    output, timed_out = _drain_process_output(proc, 0.5, None, pgid = pgid)
+    assert timed_out
+    time.sleep(4.0)  # past the grandchild's 3s sleep
+    assert not sentinel.exists(), (
+        "streamed wait timeout leaked a stdout-holding grandchild when the "
+        "process-tree kill short-circuited on the reaped leader"
+    )
+
+
+# ── GGUF loop regression: model-visible messages unchanged ───────
+
+
+def _run_gguf_tool_turn(monkeypatch, fake_execute_tool):
+    tool_stream = [
+        _sse(
+            {
+                "tool_calls": [
+                    {
+                        "id": "call_1",
+                        "index": 0,
+                        "function": {
+                            "name": "python",
+                            "arguments": json.dumps({"code": "print('hi')"}),
+                        },
+                    }
+                ]
+            }
+        ),
+        _done(),
+    ]
+    final_stream = [_sse({"content": "All done."}), _done()]
+    payloads: list[dict] = []
+    backend = _make_backend(monkeypatch, [tool_stream, final_stream], payloads)
+    monkeypatch.setattr("core.inference.tools.execute_tool", fake_execute_tool)
+    events = list(
+        backend.generate_chat_completion_with_tools(
+            messages = [{"role": "user", "content": "run it"}],
+            tools = [{"type": "function", "function": {"name": "python"}}],
+            max_tool_iterations = 1,
+        )
+    )
+    return events, payloads
+
+
+def test_gguf_loop_final_tool_message_unchanged_by_streaming(monkeypatch):
+    result_text = "hi\nline 2\n"
+
+    def plain_tool(name, arguments, **_kwargs):
+        return result_text
+
+    def streaming_tool(
+        name,
+        arguments,
+        output_callback = None,
+        **_kwargs,
+    ):
+        if output_callback is not None:
+            output_callback("hi\n")
+            output_callback("line 2\n")
+        return result_text
+
+    events_plain, payloads_plain = _run_gguf_tool_turn(monkeypatch, plain_tool)
+    events_streaming, payloads_streaming = _run_gguf_tool_turn(monkeypatch, streaming_tool)
+
+    def _tool_messages(payloads):
+        return [
+            msg for payload in payloads for msg in payload["messages"] if msg.get("role") == "tool"
+        ]
+
+    # The role=tool message fed to the model is byte-identical: streaming is purely
+    # observational and must not perturb parsing/nudging/healing.
+    assert _tool_messages(payloads_streaming) == _tool_messages(payloads_plain)
+    assert _tool_messages(payloads_streaming) == [
+        {
+            "role": "tool",
+            "name": "python",
+            "content": result_text,
+            "tool_call_id": "call_1",
+        }
+    ]
+
+    # tool_end results match too.
+    ends_plain = [e for e in events_plain if e["type"] == "tool_end"]
+    ends_streaming = [e for e in events_streaming if e["type"] == "tool_end"]
+    assert [e["result"] for e in ends_streaming] == [e["result"] for e in ends_plain]
+
+
+def test_gguf_loop_emits_tool_output_between_start_and_end(monkeypatch):
+    def streaming_tool(
+        name,
+        arguments,
+        output_callback = None,
+        **_kwargs,
+    ):
+        if output_callback is not None:
+            output_callback("progress 1\n")
+            output_callback("progress 2\n")
+        return "progress 1\nprogress 2\n"
+
+    events, _payloads = _run_gguf_tool_turn(monkeypatch, streaming_tool)
+    types = [e["type"] for e in events]
+    assert "tool_output" in types
+    start_idx = types.index("tool_start")
+    end_idx = types.index("tool_end")
+    output_indices = [i for i, t in enumerate(types) if t == "tool_output"]
+    assert all(start_idx < i < end_idx for i in output_indices)
+    streamed = "".join(e["text"] for e in events if e["type"] == "tool_output")
+    assert streamed == "progress 1\nprogress 2\n"
+    for e in events:
+        if e["type"] == "tool_output":
+            assert e["tool_name"] == "python"
+            assert e["tool_call_id"] == "call_1"
+
+
+def test_gguf_loop_plain_tool_yields_no_tool_output(monkeypatch):
+    def plain_tool(name, arguments, **_kwargs):
+        return "quiet"
+
+    events, _payloads = _run_gguf_tool_turn(monkeypatch, plain_tool)
+    assert [e for e in events if e["type"] == "tool_output"] == []
+
+
+# ── result truncation notice, env cap, missing-path healing ──────
+
+import os as _os
+import uuid as _uuid
+
+from core.inference.tools import (
+    PYTHON_TOOL,
+    TERMINAL_TOOL,
+    _MAX_OUTPUT_CHARS,
+    _env_int,
+    _missing_path_hint,
+    _truncate,
+    get_sandbox_workdir,
+)
+
+
+def test_truncate_notice_is_neutral_and_mentions_workdir():
+    out = _truncate("y" * 50, limit = 10)
+    assert out.startswith("y" * 10)
+    assert "truncated" in out and "50 chars total" in out
+    assert "persist in the working directory" in out
+    # The notice must NOT claim the user saw the output: this wrapper also serves
+    # non-streaming callers where no output_callback delivers anything.
+    assert "the user was shown the full output" not in out
+    assert "shown" not in out
+    # Under the limit: untouched.
+    assert _truncate("short", limit = 10) == "short"
+
+
+def test_truncated_result_identical_and_notice_neutral_with_streaming():
+    # The truncation notice must be byte-identical with and without an
+    # output_callback (the streaming vs non-streaming invariant a mode-dependent
+    # notice would break) and must not claim the user was shown the full output.
+    code = f"print('x' * {_MAX_OUTPUT_CHARS + 5000})"
+    baseline = _python_exec(code, timeout = 60)
+    streamed = _python_exec(code, timeout = 60, output_callback = lambda _t: None)
+    assert streamed == baseline
+    assert "truncated" in baseline
+    assert "the user was shown the full output" not in baseline
+    assert "persist in the working directory" in baseline
+
+
+def test_result_cap_env_override(monkeypatch):
+    monkeypatch.delenv("UNSLOTH_TOOL_RESULT_MAX_CHARS", raising = False)
+    assert _env_int("UNSLOTH_TOOL_RESULT_MAX_CHARS", 16000) == 16000
+    monkeypatch.setenv("UNSLOTH_TOOL_RESULT_MAX_CHARS", "50000")
+    assert _env_int("UNSLOTH_TOOL_RESULT_MAX_CHARS", 16000) == 50000
+    # Garbage and non-positive values fall back to the default.
+    monkeypatch.setenv("UNSLOTH_TOOL_RESULT_MAX_CHARS", "lots")
+    assert _env_int("UNSLOTH_TOOL_RESULT_MAX_CHARS", 16000) == 16000
+    monkeypatch.setenv("UNSLOTH_TOOL_RESULT_MAX_CHARS", "-5")
+    assert _env_int("UNSLOTH_TOOL_RESULT_MAX_CHARS", 16000) == 16000
+
+
+def test_missing_path_hint_detection():
+    err = "FileNotFoundError: [Errno 2] No such file or directory: '/mnt/data/x.html'"
+    hint = _missing_path_hint(err)
+    assert "working directory is writable" in hint
+    assert "relative path" in hint
+    # The hint echoes the actual failing path, not a canned example.
+    assert "'x.html', not '/mnt/data/x.html'" in hint
+    # A failure on a local path gets no hint.
+    assert _missing_path_hint("FileNotFoundError: 'local.txt'") == ""
+    # Mentioning /mnt/data without a file error gets no hint.
+    assert _missing_path_hint("saved to /mnt/data, all good") == ""
+    assert _missing_path_hint("") == ""
+
+
+def test_missing_path_hint_generalizes_beyond_convention_prefixes():
+    # A hallucinated absolute path outside the enumerated prefixes still earns the
+    # hint, echoing that path.
+    err = (
+        "FileNotFoundError: [Errno 2] No such file or directory: "
+        "'/home/ubuntu/Sandbox/flappy_bird.html'"
+    )
+    hint = _missing_path_hint(err)
+    assert "working directory is writable" in hint
+    assert "'flappy_bird.html', not '/home/ubuntu/Sandbox/flappy_bird.html'" in hint
+    # A bash-style error on an absolute path outside the workdir is echoed too.
+    bash_err = "cat: /var/data/report.csv: No such file or directory"
+    assert "'report.csv', not '/var/data/report.csv'" in _missing_path_hint(bash_err)
+
+
+def test_missing_path_hint_respects_project_workdir():
+    # Project-backed sessions run under a root OUTSIDE ~/studio_sandbox. A legitimate
+    # miss INSIDE that project workspace must not be misclassified as an external
+    # habit path and flattened to its basename; judged against the real workdir it
+    # gets no hint. The fabricated paths carry no convention prefix, so only the
+    # workdir judgement decides.
+    workdir = "/srv/projroot/session_area"
+    missing = "/srv/projroot/session_area/data/missing.csv"
+    output = f"FileNotFoundError: [Errno 2] No such file or directory: '{missing}'"
+    # Against the static sandbox root (no workdir) it looks external and wrongly earns the hint.
+    assert "working directory is writable" in _missing_path_hint(output)
+    # Against the real project workdir it is local -> no hint.
+    assert _missing_path_hint(output, workdir) == ""
+    # A path genuinely outside the project workdir still earns the hint.
+    outside_err = "FileNotFoundError: [Errno 2] No such file or directory: '/srv/other/x.html'"
+    assert "working directory is writable" in _missing_path_hint(outside_err, workdir)
+
+
+def test_missing_path_hint_project_workdir_under_convention_prefix():
+    # A project workdir can live under a convention prefix like /workspace (common in
+    # containers). A genuine miss INSIDE it carries the "/workspace" substring but is
+    # a real local path, not a habit path: the convention fast path must not fire and
+    # flatten it to a bare basename (which would drop the project subdirectory).
+    workdir = "/workspace/proj"
+    nested = "/workspace/proj/sub/data.csv"
+    output = f"FileNotFoundError: [Errno 2] No such file or directory: '{nested}'"
+    # Against the real project workdir the miss is local -> no hint, so
+    # /workspace/proj/sub is not flattened away.
+    assert _missing_path_hint(output, workdir) == ""
+    # A miss at the project root itself is likewise local.
+    at_root = "/workspace/proj/data.csv"
+    root_output = f"FileNotFoundError: [Errno 2] No such file or directory: '{at_root}'"
+    assert _missing_path_hint(root_output, workdir) == ""
+    # A convention path genuinely outside the project workdir still earns the
+    # hint (e.g. a /mnt/data habit path with a /workspace-rooted project).
+    outside = "FileNotFoundError: [Errno 2] No such file or directory: '/mnt/data/x.html'"
+    assert "'x.html', not '/mnt/data/x.html'" in _missing_path_hint(outside, workdir)
+    # Without an explicit workdir the default sandbox root applies, so a
+    # /workspace path is out of sandbox and keeps the habit-path hint.
+    assert "working directory is writable" in _missing_path_hint(root_output)
+
+
+def test_missing_path_hint_convention_scoped_to_failing_line():
+    # A convention prefix appearing only OUTSIDE the failing-path line (a traceback
+    # frame under /workspace, or the user's code printing /mnt/data) must not trigger
+    # the hint when the actual miss was a relative / in-workdir path.
+    frame_err = (
+        "Traceback (most recent call last):\n"
+        '  File "/workspace/proj/script.py", line 5, in <module>\n'
+        "    open('data.csv')\n"
+        "FileNotFoundError: [Errno 2] No such file or directory: 'data.csv'"
+    )
+    assert _missing_path_hint(frame_err) == ""
+    printed_err = (
+        "outputs go to /mnt/data normally\n"
+        "FileNotFoundError: [Errno 2] No such file or directory: 'notes.txt'"
+    )
+    assert _missing_path_hint(printed_err) == ""
+    # But a convention path ON the error line still earns the hint.
+    on_line = "FileNotFoundError: [Errno 2] No such file or directory: '/mnt/data/x.html'"
+    assert "'x.html', not '/mnt/data/x.html'" in _missing_path_hint(on_line)
+
+
+def test_code_tool_descriptions_mention_relative_paths():
+    for tool in (PYTHON_TOOL, TERMINAL_TOOL):
+        description = tool["function"]["description"]
+        assert "relative paths" in description
+        assert "/mnt/data" in description
+
+
+def test_python_exec_mnt_data_open_is_remapped_into_workdir():
+    # The shim remaps open()/os.makedirs() on /mnt/data into the sandbox CWD and
+    # prints a one-line stderr notice, identically with and without streaming.
+    fname = f"remap_{_uuid.uuid4().hex}.txt"
+    code = (
+        "import os\n"
+        "os.makedirs('/mnt/data', exist_ok=True)\n"
+        f"with open('/mnt/data/{fname}', 'w') as f:\n"
+        "    f.write('hello remap')\n"
+        f"print(open('/mnt/data/{fname}').read())\n"
+    )
+    target = _os.path.join(get_sandbox_workdir(), fname)
+    try:
+        baseline = _python_exec(code, timeout = 60)
+        assert _os.path.isfile(target), baseline
+        with open(target) as f:
+            assert f.read() == "hello remap"
+        assert "hello remap" in baseline
+        assert "/mnt/data does not exist in this sandbox" in baseline
+        _os.remove(target)
+        streamed = _python_exec(code, timeout = 60, output_callback = lambda _t: None)
+        assert streamed == baseline
+        assert _os.path.isfile(target)
+    finally:
+        if _os.path.exists(target):
+            _os.remove(target)
+
+
+def test_python_exec_pathlib_write_text_is_remapped_into_workdir():
+    # pathlib.Path.open / write_text / read_text call io.open directly,
+    # bypassing the builtins.open patch, so the shim must remap io.open too.
+    fname = f"remap_{_uuid.uuid4().hex}.txt"
+    code = (
+        "from pathlib import Path\n"
+        f"p = Path('/mnt/data/{fname}')\n"
+        "p.write_text('pathlib remap')\n"
+        "print(p.read_text())\n"
+    )
+    target = _os.path.join(get_sandbox_workdir(), fname)
+    try:
+        baseline = _python_exec(code, timeout = 60)
+        assert _os.path.isfile(target), baseline
+        with open(target) as f:
+            assert f.read() == "pathlib remap"
+        assert "pathlib remap" in baseline
+        assert "/mnt/data does not exist in this sandbox" in baseline
+        _os.remove(target)
+        streamed = _python_exec(code, timeout = 60, output_callback = lambda _t: None)
+        assert streamed == baseline
+        assert _os.path.isfile(target)
+    finally:
+        if _os.path.exists(target):
+            _os.remove(target)
+
+
+def test_python_exec_hallucinated_absolute_write_is_remapped_into_workdir():
+    # The model invents an absolute path outside the enumerated prefixes and opens
+    # it for writing; the write-mode fallback redirects it to the basename in the
+    # sandbox workdir instead of dying with FileNotFoundError.
+    fname = f"remap_{_uuid.uuid4().hex}.html"
+    hallucinated = f"/nonexistent_root_xyz/Sandbox/{fname}"
+    # Read-back goes through the mapped basename: reads are never redirected, only
+    # the write is healed.
+    code = (
+        f"with open('{hallucinated}', 'w') as f:\n"
+        "    f.write('hello fallback')\n"
+        f"print(open('{fname}').read())\n"
+    )
+    target = _os.path.join(get_sandbox_workdir(), fname)
+    try:
+        baseline = _python_exec(code, timeout = 60)
+        assert _os.path.isfile(target), baseline
+        with open(target) as f:
+            assert f.read() == "hello fallback"
+        assert "hello fallback" in baseline
+        assert "does not exist in this sandbox" in baseline
+        _os.remove(target)
+        streamed = _python_exec(code, timeout = 60, output_callback = lambda _t: None)
+        assert streamed == baseline
+        assert _os.path.isfile(target)
+    finally:
+        if _os.path.exists(target):
+            _os.remove(target)
+
+
+def test_python_exec_unremapped_mnt_data_failure_gets_hint():
+    # os.listdir is deliberately not remapped: the failure carries the retry hint
+    # instead, identically with and without streaming.
+    import re as _re
+
+    code = "import os\nos.listdir('/mnt/data/nonexistent_dir_xyz')\n"
+    baseline = _python_exec(code, timeout = 60)
+    assert "FileNotFoundError" in baseline
+    assert "working directory is writable" in baseline
+    streamed = _python_exec(code, timeout = 60, output_callback = lambda _t: None)
+
+    # Normalize each run's random temp filename (byte-identity is per-execution).
+    def normalize(text: str) -> str:
+        return _re.sub(r"studio_exec_\w+\.py", "studio_exec.py", text)
+
+    assert normalize(streamed) == normalize(baseline)
+
+
+def test_bash_exec_missing_path_hint():
+    baseline = _bash_exec("cat /mnt/data/definitely_missing.txt", timeout = 60)
+    assert "No such file or directory" in baseline
+    assert "working directory is writable" in baseline
+    streamed = _bash_exec(
+        "cat /mnt/data/definitely_missing.txt", timeout = 60, output_callback = lambda _t: None
+    )
+    assert streamed == baseline
+
+
+def test_bash_exec_local_failure_gets_no_hint():
+    result = _bash_exec("cat definitely_missing_local_file.txt", timeout = 60)
+    assert "No such file or directory" in result
+    assert "working directory is writable" not in result
+
+
+def test_producer_queue_is_bounded_under_tight_print_loop(monkeypatch):
+    # The consumer-side cap only bounds the concatenated stream; a fast worker can
+    # still enqueue unboundedly while the SSE consumer is backpressured. The producer
+    # boundary now discards callbacks past the cap so the queue cannot grow without
+    # limit (finding 12).
+    import queue as _queue
+
+    from core.inference import tool_stream_exec
+
+    observed = []
+
+    class _TrackingQueue(_queue.Queue):
+        def put(self, *args, **kwargs):
+            result = super().put(*args, **kwargs)
+            observed.append(self.qsize())
+            return result
+
+    monkeypatch.setattr(tool_stream_exec.queue, "Queue", _TrackingQueue)
+
+    def tool(callback):
+        for _ in range(200_000):
+            callback("x")
+        return "done"
+
+    events, result = _run_stream(tool, tool_name = "python")
+    assert result == "done"
+    # At most cap + 1 chars enter the queue, so 1-char items cannot exceed that
+    # regardless of consumer lag.
+    assert observed
+    assert max(observed) <= TOOL_OUTPUT_STREAM_MAX_CHARS + 2
+
+
+def test_continuous_over_cap_output_does_not_starve_heartbeats():
+    # Once the cap is tripped, a continuously producing tool must not spin the drain
+    # forever with no heartbeat: callbacks past the budget never enter the queue, so
+    # the idle heartbeat path resumes (finding 13).
+    release = threading.Event()
+
+    def tool(callback):
+        callback("x" * (TOOL_OUTPUT_STREAM_MAX_CHARS + 10))  # trip the cap
+        while not release.is_set():
+            callback("spam")  # discarded at the producer boundary
+        return "done"
+
+    watchdog = threading.Timer(8.0, release.set)
+    watchdog.start()
+    gen = stream_tool_execution(
+        tool,
+        tool_name = "python",
+        heartbeat_interval_s = 0.04,
+        poll_interval_s = 0.02,
+    )
+    events = []
+    result = None
+    try:
+        while True:
+            event = next(gen)
+            events.append(event)
+            if len([e for e in events if e["type"] == "heartbeat"]) >= 2:
+                release.set()
+    except StopIteration as stop:
+        result = stop.value
+    finally:
+        release.set()
+        watchdog.cancel()
+    assert result == "done"
+    assert len([e for e in events if e["type"] == "heartbeat"]) >= 2
+
+
+def test_accepts_output_callback_signature_detection():
+    from core.inference.tool_stream_exec import accepts_output_callback
+
+    def legacy(
+        name,
+        arguments,
+        cancel_event = None,
+        timeout = None,
+    ):
+        return "ok"
+
+    def modern(
+        name,
+        arguments,
+        output_callback = None,
+    ):
+        return "ok"
+
+    def kwargs_only(name, arguments, **kw):
+        return "ok"
+
+    assert accepts_output_callback(legacy) is False
+    assert accepts_output_callback(modern) is True
+    assert accepts_output_callback(kwargs_only) is True
+    # Uninspectable callables (e.g. some builtins) fall back to not-supported.
+    assert accepts_output_callback(len) is False
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_bash_exec_nonstreaming_cancel_kills_grandchild_after_leader_exit(tmp_path):
+    # NON-streaming cancellation: the leader exits at once while a grandchild holds
+    # stdout. The cancel watcher loops on the leader's poll() and is gone, so before
+    # the fix communicate() blocked until the grandchild finished. The unified drain
+    # kills the captured group on cancel instead.
+    sentinel = tmp_path / "grandchild_ran"
+    command = f"( sleep 3; touch '{sentinel}' ) & echo parent-done"
+    cancel_event = threading.Event()
+    timer = threading.Timer(0.5, cancel_event.set)
+    timer.start()
+    started = time.monotonic()
+    try:
+        result = _bash_exec(command, cancel_event = cancel_event, timeout = 30)
+    finally:
+        timer.cancel()
+    assert time.monotonic() - started < 2.5
+    assert result == "Execution cancelled."
+    time.sleep(3.5)
+    assert not sentinel.exists(), "non-streaming cancel leaked a stdout-holding grandchild"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason = "POSIX process groups")
+def test_python_exec_nonstreaming_cancel_kills_grandchild_after_leader_exit(tmp_path):
+    sentinel = tmp_path / "grandchild_ran"
+    code = (
+        "import subprocess\n"
+        f"subprocess.Popen(['bash', '-c', \"sleep 3; touch '{sentinel}'\"])\n"
+        "print('parent-done')\n"
+    )
+    cancel_event = threading.Event()
+    timer = threading.Timer(0.5, cancel_event.set)
+    timer.start()
+    started = time.monotonic()
+    try:
+        result = _python_exec(code, cancel_event = cancel_event, timeout = 30)
+    finally:
+        timer.cancel()
+    assert time.monotonic() - started < 2.5
+    assert result == "Execution cancelled."
+    time.sleep(3.5)
+    assert not sentinel.exists(), "non-streaming cancel leaked a stdout-holding grandchild"
diff --git a/studio/backend/tests/test_tool_stream_generator_drain.py b/studio/backend/tests/test_tool_stream_generator_drain.py
new file mode 100644
index 0000000000..e1d751ab09
--- /dev/null
+++ b/studio/backend/tests/test_tool_stream_generator_drain.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Regression tests for generator-close cleanup in the tool-streaming routes.
+
+Tool streams run ``next(gen)`` in an ``asyncio.to_thread`` worker. Closing the
+generator while that worker is still inside ``next`` raises ``ValueError:
+generator already executing`` and skips the generator's ``finally`` (tool
+cleanup); the routes drain the pending task first (``_drain_pending_next_task``),
+which these tests exercise.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+
+import pytest
+
+from routes.inference import _drain_pending_next_task
+
+
+def test_drain_before_close_avoids_generator_already_executing():
+    cancel_event = threading.Event()
+    entered = threading.Event()
+    finally_ran = threading.Event()
+
+    def blocking_gen():
+        try:
+            entered.set()
+            # Blocking call inside next(gen) that respects the cancel flag.
+            cancel_event.wait()
+            yield "value"
+        finally:
+            finally_ran.set()
+
+    async def scenario():
+        gen = blocking_gen()
+        next_task = asyncio.create_task(asyncio.to_thread(next, gen, object()))
+        await asyncio.to_thread(entered.wait)  # worker now inside next(gen)
+
+        # Closing mid-next races and raises, leaving the finally unrun.
+        with pytest.raises(ValueError):
+            gen.close()
+        assert not finally_ran.is_set()
+
+        # Draining sets the cancel flag so the worker returns; then close is
+        # clean and the generator's finally runs.
+        await _drain_pending_next_task(next_task, cancel_event)
+        gen.close()
+        return
+
+    asyncio.run(scenario())
+    assert finally_ran.is_set()
+
+
+def test_drain_pending_next_task_is_noop_without_task():
+    # None (task already consumed): draining is a no-op, cancel flag untouched.
+    cancel_event = threading.Event()
+
+    asyncio.run(_drain_pending_next_task(None, cancel_event))
+    assert not cancel_event.is_set()
+
+
+def test_drain_pending_next_task_returns_when_worker_finishes():
+    # A worker finishing on its own drains without error; the cancel flag stays
+    # set (the caller is tearing the stream down).
+    cancel_event = threading.Event()
+    release = threading.Event()
+
+    def gen():
+        release.wait()
+        yield "done"
+
+    async def scenario():
+        g = gen()
+        task = asyncio.create_task(asyncio.to_thread(next, g, object()))
+        release.set()  # let the worker complete before draining
+        await _drain_pending_next_task(task, cancel_event)
+        assert task.done()
+
+    asyncio.run(scenario())
+    assert cancel_event.is_set()
diff --git a/studio/backend/tests/test_web_fetch_extraction.py b/studio/backend/tests/test_web_fetch_extraction.py
new file mode 100644
index 0000000000..b794ee3e81
--- /dev/null
+++ b/studio/backend/tests/test_web_fetch_extraction.py
@@ -0,0 +1,1196 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Main-content extraction and boilerplate stripping for the web fetch tool.
+
+The HTML fixtures below snapshot the relevant fragments of a real GitHub repo
+page (github.com/unslothai/unsloth, fetched 2026-07): the ``hidden``
+client-side error placeholders ("Uh oh! There was an error while loading."),
+the skip-link / nav / footer furniture, and the README rendered inside
+``<article class="markdown-body">``. No network access is required.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_BACKEND_DIR = str(Path(__file__).resolve().parent.parent)
+if _BACKEND_DIR not in sys.path:
+    sys.path.insert(0, _BACKEND_DIR)
+
+from core.inference._html_to_md import html_to_markdown
+from core.inference.tools import (
+    _fetch_page_text,
+    _fetch_url_raw,
+    _github_repo_readme_api_url,
+    _looks_like_html,
+)
+
+
+# ── Fixtures: snapshot of GitHub repo page fragments ─────────────
+
+# GitHub ships client-side error placeholders behind the `hidden` attribute (JS
+# reveals them on a failed fetch); a text converter must not surface them.
+_GITHUB_HIDDEN_ERROR_BLOCK = """
+<div data-show-on-forbidden-error hidden>
+  <div class="Box">
+    <div class="blankslate-container">
+      <h3 class="blankslate-heading">Uh oh!</h3>
+      <p class="blankslate-description">
+        <p class="color-fg-muted my-2 mb-2 ws-normal">There was an error while loading.
+        <a class="Link--inTextBlock" href="" aria-label="Please reload this page">Please reload this page</a>.</p>
+      </p>
+    </div>
+  </div>
+</div>
+"""
+
+_GITHUB_PAGE = f"""<!DOCTYPE html>
+<html lang="en">
+<head><title>unslothai/unsloth</title></head>
+<body>
+<a class="px-2 py-4" href="#start-of-content">Skip to content</a>
+<header class="Header-old">
+  <div class="AppHeader-globalBar">
+    <a href="/login">Sign in</a>
+    <a href="/signup">Sign up</a>
+  </div>
+</header>
+<div class="js-notification-shelf"></div>
+<div hidden>
+  You signed in with another tab or window. Reload to refresh your session.
+  You signed out in another tab or window. Reload to refresh your session.
+  You switched accounts on another tab or window. Reload to refresh your session.
+  Dismiss alert
+</div>
+<template>{{{{ message }}}}</template>
+{_GITHUB_HIDDEN_ERROR_BLOCK}
+<main id="js-repo-pjax-container">
+  {_GITHUB_HIDDEN_ERROR_BLOCK}
+  <div id="repository-container-header">
+    <a href="/unslothai">unslothai</a> / <a href="/unslothai/unsloth">unsloth</a>
+    <a href="/login?return_to=%2Funslothai%2Funsloth">Notifications</a>
+    You must be signed in to change notification settings
+  </div>
+  <div class="repository-content">
+    <table aria-labelledby="folders-and-files">
+      <tr><th>Name</th><th>Last commit message</th></tr>
+      <tr><td><a href="/unslothai/unsloth/tree/main/unsloth">unsloth</a></td><td></td></tr>
+    </table>
+    <article class="markdown-body entry-content container-lg" itemprop="text">
+      <h1>Unsloth Studio</h1>
+      <p>Unsloth Studio lets you run and train models locally. Fine-tune and
+      run LLMs on Windows, Linux and macOS with a single install command,
+      then export to GGUF, Ollama, vLLM or Hugging Face when you are done.</p>
+      <h2>Install</h2>
+      <pre>curl -fsSL https://unsloth.ai/install.sh | sh</pre>
+      <p>See the <a href="https://unsloth.ai/docs">documentation</a> for
+      quickstarts, notebooks, and fine-tuning guides for every major model
+      family including Llama, Gemma, Qwen and DeepSeek.</p>
+    </article>
+  </div>
+  <div class="Layout-sidebar">
+    <h2>Languages</h2>
+    <ul>
+      <li><a href="/unslothai/unsloth/search?l=javascript">JavaScript 89.3%</a></li>
+      <li><a href="/unslothai/unsloth/search?l=python">Python 9.7%</a></li>
+    </ul>
+  </div>
+</main>
+<footer>
+  <a href="https://docs.github.com">Docs</a>
+  <a href="https://github.com/contact">Contact</a>
+</footer>
+<div aria-live="polite" aria-hidden="true">You can't perform that action at this time.</div>
+</body>
+</html>
+"""
+
+
+# ── html_to_markdown: hidden elements ────────────────────────────
+
+
+def test_hidden_attribute_subtree_is_dropped():
+    html = "<body><p>visible</p><div hidden><p>secret error text</p></div><p>after</p></body>"
+    out = html_to_markdown(html)
+    assert "visible" in out
+    assert "after" in out
+    assert "secret error text" not in out
+
+
+def test_aria_hidden_true_subtree_is_dropped():
+    html = '<body><p>keep</p><span aria-hidden="true">decoration</span></body>'
+    out = html_to_markdown(html)
+    assert "keep" in out
+    assert "decoration" not in out
+
+
+def test_aria_hidden_false_subtree_is_kept():
+    html = '<body><span aria-hidden="false">still here</span></body>'
+    assert "still here" in html_to_markdown(html)
+
+
+def test_inline_style_display_none_subtree_is_dropped():
+    # Error/loading blocks are often hidden with inline CSS rather than the
+    # ``hidden`` attribute; browsers do not render them, so they must not leak.
+    html = (
+        "<body><p>visible</p>"
+        '<div style="display:none">secret loading block</div>'
+        "<p>after</p></body>"
+    )
+    out = html_to_markdown(html)
+    assert "visible" in out
+    assert "after" in out
+    assert "secret loading block" not in out
+
+
+def test_inline_style_visibility_hidden_subtree_is_dropped():
+    html = '<body><p>keep</p><span style="visibility:hidden">ghost</span></body>'
+    out = html_to_markdown(html)
+    assert "keep" in out
+    assert "ghost" not in out
+
+
+def test_inline_style_display_none_important_is_dropped():
+    # The !important flag must not defeat the display:none detection.
+    html = '<body><p>keep</p><div style="display:none !important">gone</div></body>'
+    out = html_to_markdown(html)
+    assert "keep" in out
+    assert "gone" not in out
+
+
+def test_inline_style_display_none_among_other_declarations():
+    html = (
+        "<body><p>keep</p>" '<div style="color: red; display : none ; margin:0">gone</div></body>'
+    )
+    out = html_to_markdown(html)
+    assert "keep" in out
+    assert "gone" not in out
+
+
+def test_inline_style_visible_display_is_kept():
+    # Over-strip guard: display:block / visibility:visible render, and a value or
+    # URL merely containing the substring "none" must not trigger the hidden path.
+    html = (
+        "<body>"
+        '<div style="display:block">block kept</div>'
+        '<div style="visibility:visible">visible kept</div>'
+        '<a style="background:url(none.png)">link kept</a>'
+        "</body>"
+    )
+    out = html_to_markdown(html)
+    assert "block kept" in out
+    assert "visible kept" in out
+    assert "link kept" in out
+
+
+def test_hidden_recovers_from_omitted_close_tags():
+    # <p hidden> is never closed; the parent </div> must still end the hidden region.
+    html = "<body><div><p hidden>gone</div><p>kept</p></body>"
+    out = html_to_markdown(html)
+    assert "gone" not in out
+    assert "kept" in out
+
+
+def test_nested_hidden_regions():
+    html = "<body><div hidden><div hidden>inner</div>outer</div><p>ok</p></body>"
+    out = html_to_markdown(html)
+    assert "inner" not in out
+    assert "outer" not in out
+    assert "ok" in out
+
+
+def test_hidden_false_is_still_hidden():
+    # ``hidden`` is enumerated: the spec maps invalid/empty values to the Hidden
+    # state, so hidden="false" is NOT rendered and must not reach the Markdown.
+    html = '<body><p>keep</p><div hidden="false">not rendered</div></body>'
+    out = html_to_markdown(html)
+    assert "keep" in out
+    assert "not rendered" not in out
+
+
+def test_hidden_paragraph_omitted_close_does_not_swallow_siblings():
+    # HTML5 optional end tags: a sibling <p> start tag implicitly closes an open
+    # <p hidden>, so the hidden region ends there instead of swallowing siblings.
+    html = (
+        "<body><div><p hidden>secret"
+        "<p>visible one</p><p>visible two</p></div><p>after</p></body>"
+    )
+    out = html_to_markdown(html)
+    assert "secret" not in out
+    assert "visible one" in out
+    assert "visible two" in out
+    assert "after" in out
+
+
+def test_hidden_list_item_omitted_close_keeps_following_items():
+    # <li hidden> without </li> is implicitly closed by the next <li>.
+    html = "<body><ul><li hidden>secret<li>shown A</li><li>shown B</li></ul></body>"
+    out = html_to_markdown(html)
+    assert "secret" not in out
+    assert "shown A" in out
+    assert "shown B" in out
+
+
+def test_hr_implicitly_closes_hidden_paragraph():
+    # Void elements also imply closes: <hr> ends an open <p hidden>.
+    html = "<body><p hidden>secret<hr>kept text</body>"
+    out = html_to_markdown(html)
+    assert "secret" not in out
+    assert "kept text" in out
+
+
+def test_skipped_tag_implicitly_closes_hidden_paragraph():
+    # A skipped block (<nav>/<footer>) also closes an open <p>. The optional-close
+    # bookkeeping must run before the skip, or the never-closed <p hidden> keeps its
+    # hidden mark and swallows every following sibling.
+    for skipped in ("nav", "footer"):
+        html = f"<body><p hidden>secret<{skipped}>chrome</{skipped}>VISIBLE</body>"
+        out = html_to_markdown(html)
+        assert "secret" not in out
+        assert "chrome" not in out
+        assert "VISIBLE" in out
+
+
+def test_hidden_void_element_is_suppressed():
+    # A hidden void element (<hr>/<br>) never joins the open-element stack, so it
+    # must be suppressed inline rather than emitting its markup.
+    html = '<body><p>before</p><hr aria-hidden="true"><p>after</p></body>'
+    out = html_to_markdown(html)
+    assert "before" in out
+    assert "after" in out
+    assert "---" not in out
+
+
+def test_hidden_void_br_emits_no_break():
+    html = "<body><p>one<br hidden>two</p></body>"
+    out = html_to_markdown(html)
+    assert "one" in out
+    assert "two" in out
+    # The hidden <br> must not inject a newline between the two runs.
+    assert "one\ntwo" not in out
+
+
+def test_visible_void_hr_still_renders():
+    # Guard: the suppression must not affect non-hidden void elements.
+    html = "<body><p>a</p><hr><p>b</p></body>"
+    out = html_to_markdown(html)
+    assert "---" in out
+
+
+# ── html_to_markdown: main-content scoping ───────────────────────
+
+
+def test_github_page_main_content_keeps_readme_only():
+    out = html_to_markdown(_GITHUB_PAGE, main_content = True)
+    # README content survives.
+    assert "Unsloth Studio" in out
+    assert "install.sh" in out
+    assert "documentation" in out
+    # Client-side error placeholders and page furniture are gone.
+    assert "Uh oh!" not in out
+    assert "There was an error while loading" not in out
+    assert "Please reload this page" not in out
+    assert "You can't perform that action at this time" not in out
+    assert "Skip to content" not in out
+    assert "Sign in" not in out
+    assert "Reload to refresh your session" not in out
+    assert "JavaScript 89.3%" not in out
+    assert "Languages" not in out
+    assert "Last commit message" not in out
+
+
+def test_main_scope_used_when_no_article():
+    html = """
+    <body>
+      <header><a href="/login">Sign in</a></header>
+      <main><h1>Doc title</h1><p>%s</p></main>
+      <footer>footer junk</footer>
+    </body>
+    """ % ("Body text. " * 40)
+    out = html_to_markdown(html, main_content = True)
+    assert "Doc title" in out
+    assert "Body text." in out
+    assert "Sign in" not in out
+    assert "footer junk" not in out
+
+
+def test_main_content_falls_back_to_full_document():
+    # No article/main and a tiny body: the unscoped conversion is returned.
+    html = "<body><h1>Tiny</h1><p>Just a short page.</p></body>"
+    out = html_to_markdown(html, main_content = True)
+    assert "Tiny" in out
+    assert "Just a short page." in out
+
+
+def test_tiny_article_stub_does_not_hijack_scope():
+    # An <article> with negligible text must not swallow the real content.
+    body_text = "Real content paragraph. " * 30
+    html = f"<body><article>ad</article><main><p>{body_text}</p></main></body>"
+    out = html_to_markdown(html, main_content = True)
+    assert "Real content paragraph." in out
+
+
+def test_sibling_articles_do_not_leak_after_main_selected():
+    # The size gate picks the largest single <article> and renders only that
+    # subtree: sibling articles (related-post cards, comment threads) must not leak
+    # in just because the real article cleared the threshold.
+    real = "Main article body content for selection. " * 20
+    card = "Unrelated related-post card teaser blurb. " * 3
+    cards = "".join(f"<article><p>{card}</p></article>" for _ in range(5))
+    html = f"<body><article><h1>Real</h1><p>{real}</p></article>{cards}</body>"
+    out = html_to_markdown(html, main_content = True)
+    assert "Main article body content" in out
+    assert "Unrelated related-post" not in out
+
+
+def test_default_conversion_unscoped_and_unstripped():
+    # Without main_content the whole document converts (backwards compatible),
+    # boilerplate included; only hidden subtrees are dropped.
+    html = "<body><p>Skip to content</p><div hidden>gone</div><main><p>hello</p></main></body>"
+    out = html_to_markdown(html)
+    assert "Skip to content" in out
+    assert "hello" in out
+    assert "gone" not in out
+
+
+def test_boilerplate_filter_preserves_phrase_inside_real_prose():
+    # The furniture filter once matched by substring, deleting a real sentence that
+    # merely CONTAINS a fragment ("we use cookies"). It must drop only lines COMPOSED
+    # of furniture, keeping real prose that quotes one.
+    body = (
+        "<article><h1>Authentication</h1>"
+        "<p>We use cookies to authenticate API requests and keep sessions safe.</p>"
+        "<p>%s</p></article>"
+    ) % ("Additional documentation content to select the article. " * 8)
+    out = html_to_markdown(f"<body>{body}</body>", main_content = True)
+    assert "We use cookies to authenticate API requests" in out
+
+
+def test_boilerplate_filter_still_drops_standalone_and_stacked_furniture():
+    # A line that is purely furniture is dropped, as is one stacking several
+    # furniture phrases (as GitHub renders them).
+    body = (
+        "<article>"
+        "<p>Skip to content</p>"
+        "<p>You signed in with another tab or window. Reload to refresh your session.</p>"
+        "<p>Real README body. %s</p>"
+        "</article>"
+    ) % ("Genuine documentation text. " * 8)
+    out = html_to_markdown(f"<body>{body}</body>", main_content = True)
+    assert "Real README body." in out
+    assert "Skip to content" not in out
+    assert "Reload to refresh your session" not in out
+
+
+def test_boilerplate_not_stripped_inside_code_fences():
+    html = (
+        "<body><article><p>%s</p>"
+        "<pre>assert 'There was an error while loading' in page</pre>"
+        "</article></body>" % ("Prose. " * 40)
+    )
+    out = html_to_markdown(html, main_content = True)
+    assert "There was an error while loading" in out
+
+
+def test_aside_callout_inside_article_is_kept():
+    # Docs render notes/warnings as <aside> callouts. An aside inside the selected
+    # article/main scope is real content and must survive; dropping it unconditionally
+    # loses page text.
+    body = (
+        "<article><h1>Guide</h1>"
+        "<p>%s</p>"
+        "<aside class='admonition warning'><strong>Warning:</strong> "
+        "This operation is destructive and cannot be undone.</aside>"
+        "<p>Trailing paragraph.</p></article>"
+    ) % ("Documentation body text to select the article scope. " * 6)
+    out = html_to_markdown(f"<body>{body}</body>", main_content = True)
+    assert "This operation is destructive and cannot be undone." in out
+    assert "Warning:" in out
+    # Also kept in the unscoped (backwards-compatible) conversion.
+    out_full = html_to_markdown(f"<body>{body}</body>")
+    assert "This operation is destructive and cannot be undone." in out_full
+
+
+# ── GitHub README rewrite ────────────────────────────────────────
+
+
+def test_github_repo_url_maps_to_readme_api():
+    assert (
+        _github_repo_readme_api_url("https://github.com/unslothai/unsloth")
+        == "https://api.github.com/repos/unslothai/unsloth/readme"
+    )
+    assert (
+        _github_repo_readme_api_url("https://github.com/unslothai/unsloth/")
+        == "https://api.github.com/repos/unslothai/unsloth/readme"
+    )
+    assert (
+        _github_repo_readme_api_url("http://www.github.com/owner/repo.git")
+        == "https://api.github.com/repos/owner/repo/readme"
+    )
+
+
+def test_github_non_repo_urls_are_not_rewritten():
+    for url in (
+        "https://github.com/unslothai/unsloth/tree/main/studio",
+        "https://github.com/unslothai/unsloth/issues/123",
+        "https://github.com/topics/llm",
+        "https://github.com/orgs/unslothai/repositories",
+        "https://github.com/login/oauth",
+        "https://github.com/unslothai",
+        "https://example.com/owner/repo",
+        "https://raw.githubusercontent.com/owner/repo/main/README.md",
+    ):
+        assert _github_repo_readme_api_url(url) is None, url
+
+
+def test_fetch_page_text_prefers_github_readme(monkeypatch):
+    calls = []
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        calls.append((url, extra_headers))
+        assert url == "https://api.github.com/repos/unslothai/unsloth/readme"
+        return None, "# Unsloth\n\nFine-tune LLMs faster.", "text/plain"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth")
+    assert "Fine-tune LLMs faster." in out
+    assert "README of https://github.com/unslothai/unsloth" in out
+    assert len(calls) == 1
+    assert calls[0][1]["Accept"] == "application/vnd.github.raw+json"
+
+
+def test_fetch_page_text_keeps_html_readme_from_api(monkeypatch):
+    # A repo whose README is HTML returns HTML from the README API with a 200. That
+    # success is authoritative: convert to Markdown and keep it, never discard it in
+    # favour of the repo root page's UI chrome.
+    html_readme = (
+        "<!doctype html><html><body>"
+        "<h1>Project Title</h1>"
+        "<p>Install with the one-line script and read the docs.</p>"
+        "</body></html>"
+    )
+    calls = []
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        calls.append(url)
+        assert url == "https://api.github.com/repos/unslothai/unsloth/readme"
+        return None, html_readme, "text/html"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth")
+    # The successful README is converted and returned; no fallback fetch fires.
+    assert "README of https://github.com/unslothai/unsloth" in out
+    assert "Project Title" in out
+    assert "Install with the one-line script" in out
+    assert "<html" not in out
+    assert len(calls) == 1
+
+
+def test_fetch_page_text_falls_back_to_html_when_readme_api_fails(monkeypatch):
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        if url.startswith("https://api.github.com/"):
+            return "Failed to fetch URL: HTTP 403 rate limited", "", ""
+        return None, _GITHUB_PAGE, "text/html"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth")
+    # Fallback converts the HTML page with the main-content heuristic.
+    assert "Unsloth Studio" in out
+    assert "Uh oh!" not in out
+    assert "There was an error while loading" not in out
+
+
+def test_fetch_page_text_non_html_returned_raw(monkeypatch):
+    raw = "line one\n    indented code\nline three"
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return None, raw, "text/plain"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://raw.githubusercontent.com/o/r/main/file.txt")
+    # Whitespace preserved: the HTML renderer would have collapsed it.
+    assert "    indented code" in out
+
+
+def test_fetch_page_text_html_conversion(monkeypatch):
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return None, _GITHUB_PAGE, "text/html"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth/tree/main")
+    assert "Unsloth Studio" in out
+    assert "Uh oh!" not in out
+
+
+def test_fetch_page_text_propagates_fetch_errors(monkeypatch):
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return "Failed to fetch URL: HTTP 404 Not Found", "", ""
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    assert _fetch_page_text("https://example.com/missing") == (
+        "Failed to fetch URL: HTTP 404 Not Found"
+    )
+
+
+def test_looks_like_html():
+    assert _looks_like_html("<!DOCTYPE html><html></html>")
+    assert _looks_like_html("\n  <HTML lang='en'>")
+    assert not _looks_like_html("# Markdown README\n\n<h1>embedded html later</h1>")
+    assert not _looks_like_html("plain text")
+
+
+def test_looks_like_html_markdown_with_leading_fenced_example_stays_markdown():
+    # A Markdown README OPENING with a fenced HTML example must not be sniffed as
+    # HTML just because a doctype/tag appears in the first 256 chars; html_to_markdown
+    # would corrupt the fences and prose.
+    fenced = (
+        "```html\n<!DOCTYPE html>\n<html><body><div>hi</div></body></html>\n```\n\n# Real README\n"
+    )
+    assert not _looks_like_html(fenced)
+    # Prose that mentions a tag inline, and a centered-logo README that opens
+    # with <p align>/<div align>/<h1 align>, also stay Markdown.
+    assert not _looks_like_html("Use the <html> element to start a page.")
+    assert not _looks_like_html('<p align="center"><img src="logo.png"></p>\n\n# Project\n')
+    assert not _looks_like_html('<div align="center">\n\n# Project\n\n</div>\n')
+    assert not _looks_like_html('<h1 align="center">Project</h1>\n\nMarkdown body.\n')
+    # An autolink is not a tag opener.
+    assert not _looks_like_html("<https://example.com> is the homepage")
+
+
+def test_looks_like_html_detects_bare_fragments():
+    # A body that is a bare HTML fragment (no <html>/doctype) must still be
+    # recognized so it is converted to Markdown.
+    assert _looks_like_html("<body><p>hello</p></body>")
+    assert _looks_like_html("\n<article><h1>Title</h1><p>Body</p></article>")
+    assert _looks_like_html("<section>content</section>")
+
+
+def test_looks_like_html_leading_table_stays_markdown():
+    # Markdown READMEs routinely open with a raw HTML <table> badge row or logo
+    # layout, then continue in Markdown. Sniffing that as HTML would collapse the
+    # Markdown body, so a leading <table> (and its row/cell children) must stay
+    # Markdown, like the excluded <div align>/<p align> layout headers.
+    assert not _looks_like_html("<table><tr><td>cell</td></tr></table>")
+    assert not _looks_like_html(
+        '<table align="center"><tr><td><img src="logo.png"></td></tr></table>\n\n# Project\n'
+    )
+    assert not _looks_like_html("<tr><td>cell</td></tr>")
+
+
+def test_fetch_page_text_keeps_markdown_readme_with_html_example(monkeypatch):
+    # A Markdown README opening with a fenced HTML snippet must be served verbatim,
+    # never run through html_to_markdown (which would drop the fences/tags).
+    md_readme = (
+        "```html\n"
+        "<!DOCTYPE html>\n"
+        "<html><body><h1>Demo</h1></body></html>\n"
+        "```\n\n"
+        "# My Project\n\nInstall and run.\n"
+    )
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        assert url == "https://api.github.com/repos/unslothai/unsloth/readme"
+        return None, md_readme, "text/plain"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth")
+    assert "README of https://github.com/unslothai/unsloth" in out
+    # Markdown preserved verbatim: the fence and literal tags survive.
+    assert "```html" in out
+    assert "<!DOCTYPE html>" in out
+    assert "# My Project" in out
+
+
+def test_fetch_page_text_keeps_markdown_readme_with_leading_table(monkeypatch):
+    # A README opening with a raw HTML <table> badge/layout row then continuing in
+    # Markdown must be served verbatim, never run through html_to_markdown (which
+    # would collapse the list/fence/heading body onto one line).
+    md_readme = (
+        '<table align="center">\n'
+        '<tr><td><img src="logo.png"></td><td>Badges</td></tr>\n'
+        "</table>\n\n"
+        "# My Project\n\n"
+        "- feature one\n"
+        "- feature two\n\n"
+        "```python\nprint('hi')\n```\n"
+    )
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        assert url == "https://api.github.com/repos/unslothai/unsloth/readme"
+        return None, md_readme, "text/plain"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth")
+    assert "README of https://github.com/unslothai/unsloth" in out
+    # Markdown body verbatim: list, fence and heading survive on their own lines.
+    assert "- feature one\n- feature two" in out
+    assert "```python" in out
+    assert "# My Project" in out
+
+
+def test_fetch_url_raw_missing_content_type_reported_empty(monkeypatch):
+    # Message.get_content_type() falls back to the RFC 2045 "text/plain" default
+    # when the header is absent; _fetch_url_raw must report "" instead so the HTML
+    # sniffing fallback can fire.
+    import email
+    import urllib.request
+
+    class _FakeResp:
+        headers = email.message_from_string("")
+
+        def __init__(self):
+            self._body = b"<html><body>hello</body></html>"
+
+        def read(self, n = -1):
+            # Hand back the body once, then EOF, so the chunked reader terminates.
+            body, self._body = self._body, b""
+            return body
+
+    class _FakeOpener:
+        def open(
+            self,
+            req,
+            timeout = None,
+        ):
+            return _FakeResp()
+
+    monkeypatch.setattr(
+        "core.inference.tools._validate_and_resolve_host",
+        lambda host, port: (True, "", "203.0.113.7"),
+    )
+    monkeypatch.setattr(urllib.request, "build_opener", lambda *handlers: _FakeOpener())
+    err, body, content_type = _fetch_url_raw("https://example.com/")
+    assert err is None
+    assert "hello" in body
+    assert content_type == ""
+
+
+def test_fetch_page_text_missing_content_type_html_sniffed(monkeypatch):
+    # A header-less server returning an HTML body must still be converted.
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return None, _GITHUB_PAGE, ""
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://example.com/no-content-type")
+    assert "Unsloth Studio" in out
+    assert "<html" not in out
+    assert "Uh oh!" not in out
+
+
+def test_fetch_page_text_missing_content_type_fragment_converted(monkeypatch):
+    # A header-less server returning a bare HTML fragment (no <html>/doctype) must
+    # still be sniffed as HTML and converted, not served as raw markup.
+    fragment = "<article><h1>Doc Title</h1><p>Readable fragment body.</p></article>"
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return None, fragment, ""
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://example.com/fragment")
+    assert "Doc Title" in out
+    assert "Readable fragment body." in out
+    assert "<article" not in out
+
+
+def test_fetch_page_text_missing_content_type_plain_text_raw(monkeypatch):
+    # A header-less server returning plain text stays raw (whitespace kept).
+    raw = "line one\n    indented code\nline three"
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return None, raw, ""
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://example.com/no-content-type.txt")
+    assert "    indented code" in out
+
+
+def test_fetch_page_text_mislabeled_text_plain_html_converted(monkeypatch):
+    # An explicit text/plain header on an HTML body is sniffed and converted, like
+    # the pre-extraction behavior of always converting HTML pages.
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        return None, _GITHUB_PAGE, "text/plain"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://example.com/mislabeled")
+    assert "Unsloth Studio" in out
+    assert "<html" not in out
+
+
+# ── implicit-close past unclosed inline descendants (finding 14) ──
+
+
+def test_hidden_paragraph_with_inline_child_implicitly_closed_by_block():
+    # A browser closes an open <p> when a <div> arrives, even with an unclosed
+    # <span> on top of it. The hidden region must end there, not swallow the
+    # following visible blocks.
+    html = "<body><p hidden><span>secret<div>visible div</div><p>visible paragraph</body>"
+    out = html_to_markdown(html)
+    assert "secret" not in out
+    assert "visible div" in out
+    assert "visible paragraph" in out
+
+
+def test_hidden_list_item_with_inline_child_closed_by_next_item():
+    html = "<body><ul><li hidden><span>secret<li>visible item</ul><p>after</p></body>"
+    out = html_to_markdown(html)
+    assert "secret" not in out
+    assert "visible item" in out
+    assert "after" in out
+
+
+# ── nested hidden list/table contents must stay suppressed ──
+
+
+def test_nested_hidden_list_does_not_leak_child_items():
+    # The nested <ul> re-scopes the item, so the inner <li> is a DESCENDANT of the
+    # hidden outer <li>, not an optional-close sibling. Optional-end-tag recovery
+    # must not cross the intervening <ul>, or the outer li's hidden mark is popped
+    # and the nested text leaks.
+    html = (
+        "<body><ul>"
+        "<li hidden>parent<ul><li>secret child</li></ul></li>"
+        "<li>visible sibling</li>"
+        "</ul></body>"
+    )
+    out = html_to_markdown(html)
+    assert "parent" not in out
+    assert "secret child" not in out
+    assert "visible sibling" in out
+
+
+def test_nested_hidden_list_with_omitted_closes_stays_suppressed():
+    # Same leak, doubly nested with omitted </li>/</ul>. Every hidden descendant
+    # stays gone; the following visible sibling (which implicitly closes the hidden
+    # outer <li>) still renders.
+    html = (
+        "<body><ul>"
+        "<li hidden>parent<ul><li>secret child<ul><li>deeper secret</ul></li></ul>"
+        "<li>visible sibling"
+        "</ul></body>"
+    )
+    out = html_to_markdown(html)
+    assert "parent" not in out
+    assert "secret child" not in out
+    assert "deeper secret" not in out
+    assert "visible sibling" in out
+
+
+def test_nested_hidden_table_does_not_leak_inner_cells():
+    # A nested <table> re-scopes <tr>/<td>: an inner <td> must not be an
+    # optional-close sibling of a hidden outer <td> across the nested table.
+    html = (
+        "<body><table><tr>"
+        "<td hidden>outer<table><tr><td>secret cell</td></tr></table></td>"
+        "<td>visible cell</td>"
+        "</tr></table></body>"
+    )
+    out = html_to_markdown(html)
+    assert "secret cell" not in out
+    assert "visible cell" in out
+
+
+# ── aggregate tiny <article> cards must not displace <main> (finding 15) ──
+
+
+def test_many_tiny_articles_do_not_displace_substantial_main():
+    cards = "".join(
+        f"<article><h2>Teaser {i}</h2><p>Advertisement card blurb.</p></article>" for i in range(12)
+    )
+    main_body = "Authoritative main documentation content. " * 30
+    html = f"<body>{cards}<main><h1>Real page</h1><p>{main_body}</p></main></body>"
+    out = html_to_markdown(html, main_content = True)
+    assert "Authoritative main documentation content." in out
+    assert "Advertisement card blurb." not in out
+
+
+def test_single_substantial_article_still_preferred_over_main():
+    # GitHub-README case: one substantial <article> inside <main> must still win
+    # over sibling <main> furniture.
+    article_body = "Real README documentation body text. " * 20
+    html = (
+        "<body><main>"
+        f"<article><h1>Guide</h1><p>{article_body}</p></article>"
+        "<div><h2>Languages</h2><p>JavaScript 89.3%</p></div>"
+        "</main></body>"
+    )
+    out = html_to_markdown(html, main_content = True)
+    assert "Real README documentation body text." in out
+    assert "JavaScript 89.3%" not in out
+
+
+# ── truncated (unclosed) main-content scopes must still be scored ──
+
+
+def test_truncated_open_article_scope_is_scored_and_preferred():
+    # _fetch_url_raw caps large pages, so the download can end before the closing
+    # </article>. The scope is still the main content and must be preferred over the
+    # whole document (which re-leaks the page chrome).
+    chrome = "<nav>Skip to content</nav><div>Repository file tree and page chrome.</div>"
+    article_body = "Real README documentation body text. " * 20
+    # No closing </article> / </body> -- the fetch cap truncated the page.
+    html = f"<body>{chrome}<article><h1>Guide</h1><p>{article_body}</p>"
+    out = html_to_markdown(html, main_content = True)
+    assert "Real README documentation body text." in out
+    assert "Repository file tree and page chrome." not in out
+
+
+def test_truncated_open_main_scope_is_scored_and_preferred():
+    chrome = "<nav>Skip to content</nav><div>Repository file tree and page chrome.</div>"
+    main_body = "Authoritative main documentation content. " * 30
+    html = f"<body>{chrome}<main><h1>Doc</h1><p>{main_body}</p>"
+    out = html_to_markdown(html, main_content = True)
+    assert "Authoritative main documentation content." in out
+    assert "Repository file tree and page chrome." not in out
+
+
+# ── overall fetch deadline + cancellation (no per-hop timeout blowup) ──
+
+
+def test_fetch_url_raw_overall_deadline_aborts_across_redirects(monkeypatch):
+    # Each hop advances a fake clock by 5s; an 8s overall budget is exhausted on the
+    # third hop even though every hop stays within its own socket timeout. Without
+    # the deadline this would redirect until the 5-hop cap, so the "timed out" error
+    # proves the overall budget aborted it, not the hop cap.
+    import urllib.request
+    from urllib.error import HTTPError
+
+    import core.inference.tools as tools_mod
+
+    clock = {"t": 1000.0}
+    monkeypatch.setattr(tools_mod.time, "monotonic", lambda: clock["t"])
+
+    hops = {"n": 0}
+
+    class _RedirectingOpener:
+        def open(
+            self,
+            req,
+            timeout = None,
+        ):
+            clock["t"] += 5.0
+            hops["n"] += 1
+            raise HTTPError(
+                req.full_url,
+                302,
+                "Found",
+                {"Location": "https://example.com/next"},
+                None,
+            )
+
+    monkeypatch.setattr(
+        tools_mod,
+        "_validate_and_resolve_host",
+        lambda host, port: (True, "", "203.0.113.7"),
+    )
+    monkeypatch.setattr(urllib.request, "build_opener", lambda *handlers: _RedirectingOpener())
+
+    err, body, content_type = tools_mod._fetch_url_raw(
+        "https://example.com/start",
+        timeout = 30,
+        deadline = clock["t"] + 8.0,
+    )
+    assert err == "Failed to fetch URL: timed out."
+    assert body == ""
+    assert hops["n"] < 5
+
+
+def test_fetch_url_raw_cancel_event_aborts_before_network(monkeypatch):
+    # A set cancel_event (client disconnected) stops the fetch before it opens any
+    # socket, so a dropped stream cannot leave a tool blocking on the wire.
+    import threading
+    import urllib.request
+
+    import core.inference.tools as tools_mod
+
+    ev = threading.Event()
+    ev.set()
+    opened = {"n": 0}
+
+    class _Opener:
+        def open(
+            self,
+            req,
+            timeout = None,
+        ):
+            opened["n"] += 1
+            raise AssertionError("network must not be touched after cancel")
+
+    monkeypatch.setattr(
+        tools_mod,
+        "_validate_and_resolve_host",
+        lambda host, port: (True, "", "203.0.113.7"),
+    )
+    monkeypatch.setattr(urllib.request, "build_opener", lambda *handlers: _Opener())
+
+    err, body, content_type = tools_mod._fetch_url_raw(
+        "https://example.com/",
+        cancel_event = ev,
+    )
+    assert err == "Failed to fetch URL: cancelled."
+    assert opened["n"] == 0
+
+
+def test_fetch_page_text_shares_one_deadline_across_readme_and_fallback(monkeypatch):
+    # The README API attempt and its HTML fallback must draw from ONE budget: a
+    # failed API call cannot hand the fallback a fresh full timeout.
+    seen_deadlines = []
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        seen_deadlines.append(deadline)
+        # Fail the README API so the HTML fallback also runs.
+        return "Failed to fetch URL: HTTP 429 rate limited", "", ""
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth", timeout = 30)
+    assert out == "Failed to fetch URL: HTTP 429 rate limited"
+    # Both attempts ran and shared the same, single deadline value.
+    assert len(seen_deadlines) == 2
+    assert seen_deadlines[0] is not None
+    assert seen_deadlines[0] == seen_deadlines[1]
+
+
+# -- overall deadline reaches the body read, the resolver, and the query path --
+
+
+def test_fetch_url_raw_deadline_aborts_slow_body(monkeypatch):
+    # A server dribbling the body must not stretch the read past the overall
+    # deadline: the body is read in chunks with the budget re-checked between them,
+    # so a single slow resp.read cannot outlast the fetch budget.
+    import email
+    import urllib.request
+
+    import core.inference.tools as tools_mod
+
+    clock = {"t": 1000.0}
+    monkeypatch.setattr(tools_mod.time, "monotonic", lambda: clock["t"])
+
+    class _DrippingResp:
+        headers = email.message_from_string("")
+
+        def read(self, n = -1):
+            # One chunk, then jump the clock past the deadline so the next
+            # between-chunk budget check aborts instead of reading forever.
+            clock["t"] += 10.0
+            return b"x" * 16
+
+        def close(self):
+            pass
+
+    class _Opener:
+        def open(
+            self,
+            req,
+            timeout = None,
+        ):
+            return _DrippingResp()
+
+    monkeypatch.setattr(
+        tools_mod,
+        "_validate_and_resolve_host",
+        lambda host, port: (True, "", "203.0.113.7"),
+    )
+    monkeypatch.setattr(urllib.request, "build_opener", lambda *handlers: _Opener())
+
+    err, body, content_type = tools_mod._fetch_url_raw(
+        "https://example.com/",
+        timeout = 30,
+        deadline = clock["t"] + 5.0,
+    )
+    assert err == "Failed to fetch URL: timed out."
+    assert body == ""
+
+
+def test_resolve_with_budget_aborts_on_slow_resolver(monkeypatch):
+    # getaddrinfo has no deadline of its own; a resolver slower than the budget must
+    # abort on time instead of blocking the whole fetch.
+    import threading
+
+    import core.inference.tools as tools_mod
+
+    clock = {"t": 1000.0}
+    monkeypatch.setattr(tools_mod.time, "monotonic", lambda: clock["t"])
+
+    release = threading.Event()
+
+    def slow_resolve(host, port):
+        release.wait(5.0)  # block until released; the budget should abort first
+        return True, "", "203.0.113.7"
+
+    monkeypatch.setattr(tools_mod, "_validate_and_resolve_host", slow_resolve)
+
+    def advance_past_deadline():
+        import time as _t
+        _t.sleep(0.1)
+        clock["t"] += 100.0
+
+    t = threading.Thread(target = advance_past_deadline, daemon = True)
+    t.start()
+    try:
+        ok, reason, ip = tools_mod._resolve_with_budget(
+            "example.com",
+            443,
+            1005.0,
+            None,
+        )
+    finally:
+        release.set()
+    assert ok is False
+    assert reason == "Failed to fetch URL: timed out."
+
+
+def test_web_search_query_cancelled_skips_search(monkeypatch):
+    # A pre-set cancel_event (client disconnected) skips the blocking DDGS query,
+    # matching the direct-URL path's cancellation.
+    import sys
+    import threading
+    import types
+
+    import core.inference.tools as tools_mod
+
+    ev = threading.Event()
+    ev.set()
+    called = {"n": 0}
+
+    class _DDGS:
+        def __init__(self, *a, **k):
+            called["n"] += 1
+
+        def text(self, *a, **k):
+            called["n"] += 1
+            return []
+
+    fake_mod = types.ModuleType("ddgs")
+    fake_mod.DDGS = _DDGS
+    monkeypatch.setitem(sys.modules, "ddgs", fake_mod)
+
+    out = tools_mod._web_search("some query", cancel_event = ev)
+    assert out == "Search cancelled."
+    assert called["n"] == 0
+
+
+def test_fetch_page_text_markdown_readme_with_leading_block_tag_stays_markdown(monkeypatch):
+    # A raw-Markdown README that OPENS with an HTML block tag (<blockquote>, <ul>,
+    # <pre>, ...) must not be run through html_to_markdown, which would collapse its
+    # headings/list/fence. Only a real HTML document (doctype / <html>) is converted.
+    md_readme = (
+        "<blockquote>Note: pre-release.</blockquote>\n\n"
+        "# My Project\n\n"
+        "Install:\n\n"
+        "- step one\n"
+        "- step two\n\n"
+        "```bash\npip install myproject\n```\n"
+    )
+
+    def fake_fetch(
+        url,
+        timeout = 30,
+        extra_headers = None,
+        deadline = None,
+        cancel_event = None,
+    ):
+        assert url == "https://api.github.com/repos/unslothai/unsloth/readme"
+        return None, md_readme, "text/plain"
+
+    monkeypatch.setattr("core.inference.tools._fetch_url_raw", fake_fetch)
+    out = _fetch_page_text("https://github.com/unslothai/unsloth")
+    assert "README of https://github.com/unslothai/unsloth" in out
+    # Markdown structure survives verbatim (heading, list, fenced code).
+    assert "# My Project" in out
+    assert "- step one" in out
+    assert "```bash" in out
+
+
+def test_looks_like_html_document_only_matches_real_documents():
+    from core.inference.tools import _looks_like_html_document
+
+    assert _looks_like_html_document("<!doctype html><html><body>x</body></html>")
+    assert _looks_like_html_document("\n  <HTML lang='en'>")
+    assert _looks_like_html_document("<body><h1>x</h1></body>")
+    # Block tags a Markdown README can open with are NOT full documents.
+    for frag in (
+        "<blockquote>q</blockquote>",
+        "<ul><li>x</li></ul>",
+        "<pre>x</pre>",
+        "<dl><dt>x</dt></dl>",
+    ):
+        assert not _looks_like_html_document(frag), frag
diff --git a/studio/frontend/src/components/assistant-ui/thread.tsx b/studio/frontend/src/components/assistant-ui/thread.tsx
index 93cf162ca7..11d91cc952 100644
--- a/studio/frontend/src/components/assistant-ui/thread.tsx
+++ b/studio/frontend/src/components/assistant-ui/thread.tsx
@@ -3444,8 +3444,18 @@ const ComposerRightControls: FC<{
 const MessageError: FC = () => {
   return (
     <MessagePrimitive.Error>
-      <ErrorPrimitive.Root className="aui-message-error-root mt-2 rounded-md bg-destructive/10 p-3 text-destructive text-sm dark:bg-destructive/5 dark:text-red-200">
-        <ErrorPrimitive.Message className="aui-message-error-message line-clamp-2" />
+      <ErrorPrimitive.Root className="aui-message-error-root mt-2 flex flex-wrap items-center gap-x-3 gap-y-2 rounded-md bg-destructive/10 p-3 text-destructive text-sm dark:bg-destructive/5 dark:text-red-200">
+        <ErrorPrimitive.Message className="aui-message-error-message line-clamp-2 min-w-0 flex-1" />
+        {/* Recovery path for interrupted/failed turns: regenerate in place. */}
+        <ActionBarPrimitive.Reload asChild={true}>
+          <button
+            type="button"
+            className="aui-message-error-retry inline-flex shrink-0 items-center gap-1.5 rounded-md border border-destructive/40 px-2.5 py-1 text-xs font-medium transition-colors hover:bg-destructive/15"
+          >
+            <RefreshCwIcon strokeWidth={1.75} className="size-3.5" />
+            Retry
+          </button>
+        </ActionBarPrimitive.Reload>
       </ErrorPrimitive.Root>
     </MessagePrimitive.Error>
   );
diff --git a/studio/frontend/src/components/assistant-ui/tool-group.tsx b/studio/frontend/src/components/assistant-ui/tool-group.tsx
index 74b5e02381..469c449a70 100644
--- a/studio/frontend/src/components/assistant-ui/tool-group.tsx
+++ b/studio/frontend/src/components/assistant-ui/tool-group.tsx
@@ -10,6 +10,7 @@ import {
 } from "react";
 import { useAuiState } from "@assistant-ui/react";
 import { useChatRuntimeStore } from "@/features/chat/stores/chat-runtime-store";
+import { toolOutputKey, useToolPaneScope } from "@/features/chat";
 import { ChevronDownIcon } from "lucide-react";
 import { Wrench01Icon } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
@@ -235,13 +236,29 @@ const ToolGroupImpl: FC<
   const messageRunning = useAuiState(
     ({ message }) => message.status?.type === "running",
   );
-  // Keep the group open once a confirmation forced it open, so answering an
-  // allow/deny doesn't snap it shut between sequential tool calls. It reverts
-  // to the default collapsed state once the turn finishes.
+  // Force the group open when any call is receiving tool_output events.
+  const toolLiveOutput = useChatRuntimeStore((s) => s.toolLiveOutput);
+  const paneScope = useToolPaneScope();
+  const hasLiveOutput = useAuiState(({ message }) =>
+    message.parts
+      .slice(startIndex, endIndex + 1)
+      .some(
+        (part) =>
+          part.type === "tool-call" &&
+          Object.prototype.hasOwnProperty.call(
+            toolLiveOutput,
+            toolOutputKey(paneScope, part.toolCallId),
+          ),
+      ),
+  );
+  // Keep the group open once a confirmation or live output forced it (so an
+  // allow/deny doesn't snap it shut between calls); reverts once the turn ends.
   const forcedOpenRef = useRef(false);
-  if (hasPendingConfirmation) forcedOpenRef.current = true;
+  if (hasPendingConfirmation || hasLiveOutput) forcedOpenRef.current = true;
   const forceOpen =
-    hasPendingConfirmation || (forcedOpenRef.current && messageRunning);
+    hasPendingConfirmation ||
+    (hasLiveOutput && messageRunning) ||
+    (forcedOpenRef.current && messageRunning);
 
   // Render single tool calls and canvases directly so cards never hide in a
   // collapsed group.
diff --git a/studio/frontend/src/components/assistant-ui/tool-live-output.tsx b/studio/frontend/src/components/assistant-ui/tool-live-output.tsx
new file mode 100644
index 0000000000..3434783f0a
--- /dev/null
+++ b/studio/frontend/src/components/assistant-ui/tool-live-output.tsx
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"use client";
+
+import { useChatRuntimeStore } from "@/features/chat/stores/chat-runtime-store";
+import { toolOutputKey, useToolPaneScope } from "@/features/chat";
+import { useEffect, useMemo, useRef } from "react";
+import { tailText } from "./tool-result-output";
+
+/**
+ * Live-scrolling stdout/stderr pane for a running server-side tool, backed by
+ * the transient `toolLiveOutput` map fed by `tool_output` SSE events. Renders
+ * nothing until the first chunk, then follows the tail. Mounted only while
+ * running; the finished card shows the persisted result instead.
+ */
+export function ToolLiveOutput({ toolCallId }: { toolCallId: string }) {
+  const paneScope = useToolPaneScope();
+  const output = useChatRuntimeStore(
+    (s) => s.toolLiveOutput[toolOutputKey(paneScope, toolCallId)] ?? "",
+  );
+  const scrollRef = useRef<HTMLPreElement>(null);
+  // Pinned to the bottom until the user scrolls up (handler below), so
+  // streaming chunks no longer yank them down.
+  const pinnedToBottom = useRef(true);
+
+  // The stream can reach hundreds of KB; render only the tail while live.
+  const visible = useMemo(() => tailText(output).visible, [output]);
+
+  const handleScroll = () => {
+    const el = scrollRef.current;
+    if (!el) {
+      return;
+    }
+    // Within 40px of the bottom counts as pinned (tolerates small nudges).
+    pinnedToBottom.current =
+      el.scrollHeight - el.scrollTop - el.clientHeight < 40;
+  };
+
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (el && pinnedToBottom.current) {
+      el.scrollTop = el.scrollHeight;
+    }
+  }, [visible]);
+
+  if (!output) {
+    return null;
+  }
+
+  return (
+    <div className="aui-tool-live-output mt-2 border-t border-dashed pt-2">
+      <span className="text-xs font-medium text-muted-foreground">output</span>
+      <pre
+        ref={scrollRef}
+        onScroll={handleScroll}
+        className="mt-1 max-h-60 overflow-auto whitespace-pre-wrap break-words font-mono text-xs"
+      >
+        {visible}
+      </pre>
+    </div>
+  );
+}
diff --git a/studio/frontend/src/components/assistant-ui/tool-result-output.tsx b/studio/frontend/src/components/assistant-ui/tool-result-output.tsx
new file mode 100644
index 0000000000..45f72ed96c
--- /dev/null
+++ b/studio/frontend/src/components/assistant-ui/tool-result-output.tsx
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"use client";
+
+import { useMemo, useState } from "react";
+
+/** Tail-line cap so a huge output never mounts a megabyte <pre> block. */
+const TAIL_LINES = 2000;
+/** Char backstop for pathological single-line outputs. */
+const TAIL_CHARS = 200_000;
+
+interface Tail {
+  visible: string;
+  hiddenLines: number;
+  hiddenChars: number;
+}
+
+export function tailText(text: string): Tail {
+  let visible = text;
+  let hiddenLines = 0;
+  let hiddenChars = 0;
+  const lines = visible.split("\n");
+  if (lines.length > TAIL_LINES) {
+    hiddenLines = lines.length - TAIL_LINES;
+    visible = lines.slice(hiddenLines).join("\n");
+  }
+  if (visible.length > TAIL_CHARS) {
+    hiddenChars = visible.length - TAIL_CHARS;
+    visible = visible.slice(hiddenChars);
+  }
+  return { visible, hiddenLines, hiddenChars };
+}
+
+/**
+ * Finished-tool output pane: renders the tail (~2000 lines) with a "Show all"
+ * toggle so a large output stays scrollable without janking the DOM. Copy
+ * buttons still copy the FULL text (owned by the caller), not the tail.
+ */
+export function ToolResultOutput({ text }: { text: string }) {
+  const [showAll, setShowAll] = useState(false);
+  const tail = useMemo(() => tailText(text), [text]);
+  const truncated = !showAll && (tail.hiddenLines > 0 || tail.hiddenChars > 0);
+
+  return (
+    <>
+      {truncated && (
+        <button
+          type="button"
+          onClick={() => setShowAll(true)}
+          className="mt-1 rounded px-1.5 py-0.5 text-xs text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+        >
+          {tail.hiddenLines > 0
+            ? `Show all (${tail.hiddenLines.toLocaleString()} earlier lines hidden)`
+            : `Show all (${tail.hiddenChars.toLocaleString()} earlier chars hidden)`}
+        </button>
+      )}
+      <pre className="mt-1 max-h-60 overflow-auto whitespace-pre-wrap break-words font-mono text-xs">
+        {showAll ? text : tail.visible}
+      </pre>
+    </>
+  );
+}
diff --git a/studio/frontend/src/components/assistant-ui/tool-ui-python.tsx b/studio/frontend/src/components/assistant-ui/tool-ui-python.tsx
index 1afffaed7d..1b3dd22000 100644
--- a/studio/frontend/src/components/assistant-ui/tool-ui-python.tsx
+++ b/studio/frontend/src/components/assistant-ui/tool-ui-python.tsx
@@ -6,6 +6,7 @@
 import { copyToClipboard } from "@/lib/copy-to-clipboard";
 import { getAuthToken } from "@/features/auth/session";
 import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { useToolArgsStatus } from "@assistant-ui/react";
 import { code as codePlugin } from "@streamdown/code";
 import { CodeIcon, CopyIcon } from "lucide-react";
 import { Tick02Icon } from "@/lib/tick-icon";
@@ -18,6 +19,14 @@ import {
   ToolFallbackRoot,
   ToolFallbackTrigger,
 } from "./tool-fallback";
+import { ToolLiveOutput } from "./tool-live-output";
+import { ToolResultOutput } from "./tool-result-output";
+import { useChatRuntimeStore } from "@/features/chat/stores/chat-runtime-store";
+import {
+  preferFullToolOutput,
+  toolOutputKey,
+  useToolPaneScope,
+} from "@/features/chat";
 
 interface StructuredResult {
   text: string;
@@ -105,6 +114,7 @@ function isStructuredResult(val: unknown): val is StructuredResult {
 }
 
 const PythonToolUIImpl: ToolCallMessagePartComponent = ({
+  toolCallId,
   args,
   result,
   status,
@@ -112,6 +122,9 @@ const PythonToolUIImpl: ToolCallMessagePartComponent = ({
   const code = (args as { code?: string })?.code ?? "";
   const firstLine = code.split("\n")[0]?.slice(0, 60) ?? "";
   const isRunning = status?.type === "running";
+  // Args still streaming = the model is WRITING the code, not running it yet.
+  const { propStatus } = useToolArgsStatus();
+  const isWritingCode = isRunning && propStatus.code === "streaming";
 
   let output: string;
   let images: string[] = [];
@@ -129,10 +142,19 @@ const PythonToolUIImpl: ToolCallMessagePartComponent = ({
     output = "";
   }
 
+  // Show the fuller live stream over a truncated result, keeping its exit
+  // status. Session-transient: after a reload only the result remains.
+  const paneScope = useToolPaneScope();
+  const fullOutput = useChatRuntimeStore(
+    (s) => s.toolFullOutput[toolOutputKey(paneScope, toolCallId)] ?? "",
+  );
+  const displayOutput = preferFullToolOutput(fullOutput, output);
+
   const authToken = getAuthToken();
 
   return (
-    <ToolFallbackRoot>
+    // Open when mounted mid-run so live output shows; collapsed from history.
+    <ToolFallbackRoot defaultOpen={isRunning}>
       <ToolFallbackTrigger
         toolName={firstLine ? `Python: ${firstLine}` : "Python"}
         status={status}
@@ -150,19 +172,21 @@ const PythonToolUIImpl: ToolCallMessagePartComponent = ({
 
           {/* Output */}
           {isRunning ? (
-            <div className="mt-2 flex items-center gap-2 text-sm text-muted-foreground">
-              <Spinner className="size-3.5" />
-              <span>Running&hellip;</span>
-            </div>
-          ) : output ? (
+            <>
+              <div className="mt-2 flex items-center gap-2 text-sm text-muted-foreground">
+                <Spinner className="size-3.5" />
+                <span>{isWritingCode ? "Writing code…" : "Running…"}</span>
+              </div>
+              {/* Live stdout streamed via tool_output SSE events. */}
+              <ToolLiveOutput toolCallId={toolCallId} />
+            </>
+          ) : displayOutput ? (
             <div className="mt-2 border-t border-dashed pt-2">
               <div className="flex items-center justify-between">
                 <span className="text-xs font-medium text-muted-foreground">output</span>
-                <CopyBtn text={output} />
+                <CopyBtn text={displayOutput} />
               </div>
-              <pre className="mt-1 max-h-60 overflow-auto whitespace-pre-wrap break-words font-mono text-xs">
-                {truncate(output)}
-              </pre>
+              <ToolResultOutput text={displayOutput} />
             </div>
           ) : null}
 
diff --git a/studio/frontend/src/components/assistant-ui/tool-ui-terminal.tsx b/studio/frontend/src/components/assistant-ui/tool-ui-terminal.tsx
index c088d5cf98..17ae26d388 100644
--- a/studio/frontend/src/components/assistant-ui/tool-ui-terminal.tsx
+++ b/studio/frontend/src/components/assistant-ui/tool-ui-terminal.tsx
@@ -5,6 +5,7 @@
 
 import { copyToClipboard } from "@/lib/copy-to-clipboard";
 import type { ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { useToolArgsStatus } from "@assistant-ui/react";
 import { CopyIcon, TerminalIcon } from "lucide-react";
 import { Tick02Icon } from "@/lib/tick-icon";
 import { HugeiconsIcon } from "@hugeicons/react";
@@ -15,16 +16,17 @@ import {
   ToolFallbackRoot,
   ToolFallbackTrigger,
 } from "./tool-fallback";
+import { ToolLiveOutput } from "./tool-live-output";
+import { ToolResultOutput } from "./tool-result-output";
+import { useChatRuntimeStore } from "@/features/chat/stores/chat-runtime-store";
+import {
+  preferFullToolOutput,
+  toolOutputKey,
+  useToolPaneScope,
+} from "@/features/chat";
 
-const MAX_DISPLAY = 10_000;
 const COPY_RESET_MS = 2000;
 
-function truncate(text: string): string {
-  return text.length <= MAX_DISPLAY
-    ? text
-    : `${text.slice(0, MAX_DISPLAY)}\n... (truncated)`;
-}
-
 function CopyBtn({ text }: { text: string }) {
   const [copied, setCopied] = useState(false);
   const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -65,12 +67,16 @@ function CopyBtn({ text }: { text: string }) {
 }
 
 const TerminalToolUIImpl: ToolCallMessagePartComponent = ({
+  toolCallId,
   args,
   result,
   status,
 }) => {
   const command = (args as { command?: string })?.command ?? "";
   const isRunning = status?.type === "running";
+  // Args still streaming = the model is WRITING the command, not running it yet.
+  const { propStatus } = useToolArgsStatus();
+  const isWritingCommand = isRunning && propStatus.command === "streaming";
   const output =
     typeof result === "string"
       ? result
@@ -78,8 +84,17 @@ const TerminalToolUIImpl: ToolCallMessagePartComponent = ({
         ? JSON.stringify(result, null, 2)
         : "";
 
+  // Show the fuller live stream over a truncated result, keeping its exit
+  // status. Session-transient: after a reload only the result remains.
+  const paneScope = useToolPaneScope();
+  const fullOutput = useChatRuntimeStore(
+    (s) => s.toolFullOutput[toolOutputKey(paneScope, toolCallId)] ?? "",
+  );
+  const displayOutput = preferFullToolOutput(fullOutput, output);
+
   return (
-    <ToolFallbackRoot>
+    // Open when mounted mid-run so live output shows; collapsed from history.
+    <ToolFallbackRoot defaultOpen={isRunning}>
       <ToolFallbackTrigger
         toolName={command ? `$ ${command.slice(0, 60)}` : "Terminal"}
         status={status}
@@ -88,19 +103,21 @@ const TerminalToolUIImpl: ToolCallMessagePartComponent = ({
       <ToolFallbackContent>
         <div className="border-l-2 border-muted-foreground/20 pl-2">
           {isRunning ? (
-            <div className="flex items-center gap-2 text-sm text-muted-foreground">
-              <Spinner className="size-3.5" />
-              <span>Running&hellip;</span>
-            </div>
-          ) : output ? (
+            <>
+              <div className="flex items-center gap-2 text-sm text-muted-foreground">
+                <Spinner className="size-3.5" />
+                <span>{isWritingCommand ? "Writing command…" : "Running…"}</span>
+              </div>
+              {/* Live stdout streamed via tool_output SSE events. */}
+              <ToolLiveOutput toolCallId={toolCallId} />
+            </>
+          ) : displayOutput ? (
             <div>
               <div className="flex items-center justify-between">
                 <span className="text-xs font-medium text-muted-foreground">output</span>
-                <CopyBtn text={output} />
+                <CopyBtn text={displayOutput} />
               </div>
-              <pre className="mt-1 max-h-60 overflow-auto whitespace-pre-wrap break-words font-mono text-xs">
-                {truncate(output)}
-              </pre>
+              <ToolResultOutput text={displayOutput} />
             </div>
           ) : null}
         </div>
diff --git a/studio/frontend/src/features/chat/api/chat-adapter.ts b/studio/frontend/src/features/chat/api/chat-adapter.ts
index c7dd6372aa..0bf46e7343 100644
--- a/studio/frontend/src/features/chat/api/chat-adapter.ts
+++ b/studio/frontend/src/features/chat/api/chat-adapter.ts
@@ -12,6 +12,7 @@ import { parseParamCountB } from "@/lib/model-size";
 import { toast } from "@/lib/toast";
 import type { MessageTiming, ToolCallMessagePart } from "@assistant-ui/core";
 import type { ChatModelAdapter } from "@assistant-ui/react";
+import { parsePartialJsonObject } from "assistant-stream/utils";
 import {
   getExternalProviderApiKey,
   isCustomProviderType,
@@ -51,6 +52,11 @@ import {
   useChatRuntimeStore,
 } from "../stores/chat-runtime-store";
 import { useExternalProvidersStore } from "../stores/external-providers-store";
+import {
+  shouldPreserveFullOutput,
+  toolOutputKey,
+  toolPaneScope,
+} from "../tool-output-scope";
 import type { ModelType } from "../types";
 import { isMultimodalResponse } from "../types/api";
 import type {
@@ -85,6 +91,7 @@ import {
   listGgufVariants,
   loadModel,
   streamChatCompletions,
+  StreamInterruptedError,
   validateModel,
 } from "./chat-api";
 import {
@@ -228,6 +235,49 @@ function wait(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Best-effort partial parse of a live tool_args stream into a tool part's
+ * `args`, so cards render the payload while the model is still writing it. The
+ * structured path streams raw arguments JSON; the text path wraps it in call
+ * markup, unwrapped here. Returns null until something parses; never throws.
+ */
+function parseLiveToolArgs(
+  raw: string,
+): { args: Record<string, unknown>; argsText: string } | null {
+  let candidate = raw.trimStart();
+  if (!candidate.startsWith("{")) {
+    const brace = candidate.indexOf("{");
+    if (brace < 0) return null;
+    candidate = candidate.slice(brace);
+  }
+  const parsed = parsePartialJsonObject(candidate) as
+    | Record<string, unknown>
+    | undefined;
+  if (!parsed || typeof parsed !== "object") return null;
+  // Call envelope from the text path: unwrap to the arguments payload.
+  const inner = parsed.arguments ?? parsed.parameters;
+  if (typeof parsed.name === "string" && inner !== undefined) {
+    if (typeof inner === "string") {
+      // Stringified arguments: partial-parse the inner JSON string.
+      const innerParsed = parsePartialJsonObject(inner) as
+        | Record<string, unknown>
+        | undefined;
+      if (innerParsed && typeof innerParsed === "object") {
+        return { args: innerParsed, argsText: inner };
+      }
+      return null;
+    }
+    if (inner && typeof inner === "object" && !Array.isArray(inner)) {
+      return {
+        args: inner as Record<string, unknown>,
+        argsText: JSON.stringify(inner),
+      };
+    }
+    return null;
+  }
+  return { args: parsed, argsText: candidate };
+}
+
 function parseSystemVariablesMap(raw: string): Record<string, unknown> {
   if (!raw.trim()) {
     return {};
@@ -1877,6 +1927,16 @@ export function createOpenAIStreamAdapter(
         ? `${sandboxSessionId || "_default"}:${resolvedThreadId}`
         : sandboxSessionId || "_default";
       const toolConfirmationIdsByBackendId = new Map<string, string>();
+      // Store keys are pane-scoped since local tool ids ("call_0") repeat across
+      // turns and concurrent panes (compare mode). Track this run's keys so
+      // cleanup can't wipe another pane's.
+      const toolOutputPaneScope = toolPaneScope(
+        options.modelType,
+        options.pairId,
+      );
+      const scopedToolOutputKey = (id: string) =>
+        toolOutputKey(toolOutputPaneScope, id);
+      const runToolLiveOutputKeys = new Set<string>();
       const resolvedThreadKey = resolvedThreadId ?? null;
       const pendingImageEditReferenceForRun = runtime.pendingImageEditReference;
       const selectedImageEditReference =
@@ -2426,6 +2486,34 @@ export function createOpenAIStreamAdapter(
       };
       // Tool call parts, cumulative; result lands on tool_end.
       const toolCallParts: PositionedToolCallPart[] = [];
+      // Raw tool_args accumulator per card: the backend forwards arguments while
+      // the model is still WRITING them, and the partial parse below feeds the
+      // card's args so the code renders live.
+      const liveArgsTextById = new Map<string, string>();
+      // Backend tool ids ("call_0", ...) restart every response, so a bare id as
+      // store key lets a later turn's stream overwrite the preserved output an
+      // earlier still-mounted finished card reads (the tool_start stale-clear
+      // only guards the forward direction). Mint one per-run-unique part id per
+      // backend id (confirmation ids already synthesize their own) so each card
+      // key is unique; every tool_start/output/args/end resolves the same id via
+      // this map, dropped at tool_end.
+      const toolPartIdByBackendId = new Map<string, string>();
+      const resolveToolPartId = (backendToolCallId: string): string => {
+        if (!backendToolCallId) {
+          return toolCallParts[toolCallParts.length - 1]?.toolCallId ?? "";
+        }
+        const confirmationId =
+          toolConfirmationIdsByBackendId.get(backendToolCallId);
+        if (confirmationId) {
+          return confirmationId;
+        }
+        let partId = toolPartIdByBackendId.get(backendToolCallId);
+        if (!partId) {
+          partId = `${backendToolCallId}:${crypto.randomUUID()}`;
+          toolPartIdByBackendId.set(backendToolCallId, partId);
+        }
+        return partId;
+      };
       // Latest Gemini text-part thoughtSignature; pinned onto the final
       // text MessagePart so next-turn replay carries it.
       let latestTextThoughtSignature: string | undefined;
@@ -3160,6 +3248,66 @@ export function createOpenAIStreamAdapter(
                   anthropicRefusalSeen = true;
                   continue;
                 }
+                if (toolEvent.type === "tool_output") {
+                  // Incremental stdout from a running tool: append to the live
+                  // store so the card renders it while the spinner runs. Final
+                  // result arrives via tool_end.
+                  const backendToolCallId =
+                    (toolEvent.tool_call_id as string) || "";
+                  const liveId = resolveToolPartId(backendToolCallId);
+                  const liveText =
+                    typeof toolEvent.text === "string" ? toolEvent.text : "";
+                  if (liveId && liveText) {
+                    const liveKey = scopedToolOutputKey(liveId);
+                    runToolLiveOutputKeys.add(liveKey);
+                    useChatRuntimeStore
+                      .getState()
+                      .appendToolLiveOutput(liveKey, liveText);
+                  }
+                  continue;
+                }
+                if (toolEvent.type === "tool_args") {
+                  // The model is still WRITING this call's arguments: accumulate
+                  // the raw stream and feed a partial parse into the part's args
+                  // so the card shows the code live. tool_start later replaces
+                  // args with the authoritative parse.
+                  const backendToolCallId =
+                    (toolEvent.tool_call_id as string) || "";
+                  const liveId = resolveToolPartId(backendToolCallId);
+                  const fragment =
+                    typeof toolEvent.text === "string" ? toolEvent.text : "";
+                  if (liveId && fragment) {
+                    const accum =
+                      (liveArgsTextById.get(liveId) ?? "") + fragment;
+                    liveArgsTextById.set(liveId, accum);
+                    const partial = parseLiveToolArgs(accum);
+                    const idx = toolCallParts.findIndex(
+                      (p) => p.toolCallId === liveId,
+                    );
+                    if (partial && idx !== -1) {
+                      const existing = toolCallParts[
+                        idx
+                      ] as PositionedToolCallPart;
+                      toolCallParts[idx] = {
+                        ...existing,
+                        args: partial.args as ToolCallMessagePart["args"],
+                        argsText: partial.argsText,
+                      };
+                      yield {
+                        content: buildAssistantContent(cumulativeText),
+                        metadata: {
+                          timing: buildTiming(
+                            streamStartTime,
+                            totalChunks,
+                            firstTokenTime,
+                          ),
+                          custom: { reasoningDuration },
+                        },
+                      };
+                    }
+                  }
+                  continue;
+                }
                 closeReasoningContent();
                 const toolProvenance = parseToolProvenance(
                   toolEvent.provenance,
@@ -3173,12 +3321,18 @@ export function createOpenAIStreamAdapter(
                   const id =
                     awaitingConfirmation && approvalId
                       ? `${toolConfirmationScopeId}:${approvalId}`
-                      : backendToolCallId ||
-                        approvalId ||
-                        `${toolEvent.tool_name}_${Date.now()}`;
+                      : backendToolCallId
+                        ? resolveToolPartId(backendToolCallId)
+                        : approvalId ||
+                          `${toolEvent.tool_name}_${Date.now()}`;
                   if (awaitingConfirmation && backendToolCallId) {
                     toolConfirmationIdsByBackendId.set(backendToolCallId, id);
                   }
+                  // "call_0" restarts every response: drop stale live/preserved
+                  // output under this key, else the card shows the previous call's.
+                  const staleKey = scopedToolOutputKey(id);
+                  useChatRuntimeStore.getState().clearToolLiveOutput(staleKey);
+                  useChatRuntimeStore.getState().clearToolFullOutput(staleKey);
                   const toolArgs = (toolEvent.arguments ??
                     {}) as ToolCallMessagePart["args"];
                   const idx = toolCallParts.findIndex(
@@ -3222,17 +3376,35 @@ export function createOpenAIStreamAdapter(
                 } else if (toolEvent.type === "tool_end") {
                   const backendToolCallId =
                     (toolEvent.tool_call_id as string) || "";
-                  const id =
-                    (backendToolCallId
-                      ? toolConfirmationIdsByBackendId.get(backendToolCallId)
-                      : undefined) ||
-                    backendToolCallId ||
-                    toolCallParts[toolCallParts.length - 1]?.toolCallId ||
-                    "";
+                  const id = resolveToolPartId(backendToolCallId);
                   if (backendToolCallId) {
                     toolConfirmationIdsByBackendId.delete(backendToolCallId);
+                    toolPartIdByBackendId.delete(backendToolCallId);
                   }
                   useChatRuntimeStore.getState().clearToolConfirmation(id);
+                  // The result replaces the live output, but if the stream
+                  // captured MORE than the truncated result, preserve it so the
+                  // finished card keeps everything. Uses the shared predicate,
+                  // not a length compare (footer / "Exit code N:" / __IMAGES__
+                  // tail can make the result longer by byte).
+                  const liveKey = scopedToolOutputKey(id);
+                  const liveOutput =
+                    useChatRuntimeStore.getState().toolLiveOutput[liveKey] ??
+                    "";
+                  if (
+                    id &&
+                    shouldPreserveFullOutput(
+                      liveOutput,
+                      (toolEvent.result as string) ?? "",
+                    )
+                  ) {
+                    useChatRuntimeStore
+                      .getState()
+                      .setToolFullOutput(liveKey, liveOutput);
+                  }
+                  useChatRuntimeStore.getState().clearToolLiveOutput(liveKey);
+                  runToolLiveOutputKeys.delete(liveKey);
+                  liveArgsTextById.delete(id);
                   const idx = toolCallParts.findIndex(
                     (p) => p.toolCallId === id,
                   );
@@ -3797,7 +3969,16 @@ export function createOpenAIStreamAdapter(
         );
         if (!abortSignal.aborted) {
           const msg = err instanceof Error ? err.message : String(err);
-          if (isContextLimitError(msg)) {
+          if (err instanceof StreamInterruptedError) {
+            // Connection dropped mid-turn: surface it explicitly (the rethrow
+            // below also marks the message with an inline error + Retry).
+            toast.error("Response interrupted", {
+              description:
+                "The connection dropped before the model finished. " +
+                "The partial answer is kept. Use Retry to regenerate.",
+              duration: 8000,
+            });
+          } else if (isContextLimitError(msg)) {
             // llama-server runs with --no-context-shift, returning a hard
             // error instead of silently dropping old KV-cache turns. Point
             // the user at the control that raises the ceiling.
@@ -3823,6 +4004,19 @@ export function createOpenAIStreamAdapter(
         }
         runtime.setGeneratingStatus(null);
         runtime.setToolStatus(null);
+        // Clear only this run's live keys (a concurrent pane owns its own). A
+        // key still here streamed stdout but never reached tool_end (SSE drop or
+        // cancel), so promote it to full output first, else the partial
+        // diagnostics the user was watching vanish from the card.
+        for (const liveKey of runToolLiveOutputKeys) {
+          const store = useChatRuntimeStore.getState();
+          const liveOutput = store.toolLiveOutput[liveKey] ?? "";
+          if (liveOutput) {
+            store.setToolFullOutput(liveKey, liveOutput);
+          }
+          store.clearToolLiveOutput(liveKey);
+        }
+        runToolLiveOutputKeys.clear();
         // Drop the transient denoising canvas so the finished bubble shows only
         // the committed markdown answer (cancellation/error included).
         runtime.setActiveDiffusionCanvas(null);
diff --git a/studio/frontend/src/features/chat/api/chat-api.ts b/studio/frontend/src/features/chat/api/chat-api.ts
index 8195d89528..ebf9461172 100644
--- a/studio/frontend/src/features/chat/api/chat-api.ts
+++ b/studio/frontend/src/features/chat/api/chat-api.ts
@@ -29,6 +29,21 @@ import type {
 
 export const CHAT_HISTORY_UPDATED_EVENT = "unsloth-chat-history-updated";
 
+/**
+ * Thrown when the chat SSE stream ends without a terminal signal (`[DONE]` or a
+ * finish_reason chunk): the connection dropped mid-generation. The adapter
+ * surfaces it as an explicit interrupted state instead of ending the turn.
+ */
+export class StreamInterruptedError extends Error {
+  constructor() {
+    super(
+      "Response interrupted: the connection dropped before the model finished. " +
+        "Use Retry to regenerate.",
+    );
+    this.name = "StreamInterruptedError";
+  }
+}
+
 export function notifyChatHistoryUpdated(): void {
   if (typeof window !== "undefined") {
     window.dispatchEvent(new Event(CHAT_HISTORY_UPDATED_EVENT));
@@ -851,12 +866,18 @@ export async function* streamChatCompletions(
   const decoder = new TextDecoder();
   let buffer = "";
   let completed = false;
+  // EOF without `[DONE]` or a finish_reason chunk means the stream was cut
+  // mid-generation: surface as interrupted, not silent success.
+  let sawTerminalSignal = false;
 
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) {
         completed = true;
+        if (!sawTerminalSignal) {
+          throw new StreamInterruptedError();
+        }
         break;
       }
 
@@ -877,6 +898,7 @@ export async function* streamChatCompletions(
         const dataText = dataLines.join("\n");
         if (dataText === "[DONE]") {
           completed = true;
+          sawTerminalSignal = true;
           return;
         }
 
@@ -903,10 +925,14 @@ export async function* streamChatCompletions(
           separatorIndex = buffer.search(/\r?\n\r?\n/);
           continue;
         }
-        // Tool start/end events carry full input/output for the tool outputs panel
+        // tool_start/end carry full input/output; tool_output streams
+        // incremental stdout and tool_args streams the call arguments live.
         if (
           "type" in parsed &&
-          (parsed.type === "tool_start" || parsed.type === "tool_end")
+          (parsed.type === "tool_start" ||
+            parsed.type === "tool_end" ||
+            parsed.type === "tool_output" ||
+            parsed.type === "tool_args")
         ) {
           yield { _toolEvent: parsed } as unknown as OpenAIChatChunk;
           separatorIndex = buffer.search(/\r?\n\r?\n/);
@@ -925,6 +951,16 @@ export async function* streamChatCompletions(
           separatorIndex = buffer.search(/\r?\n\r?\n/);
           continue;
         }
+        // finish_reason is a valid terminal signal for providers that close
+        // the stream without an explicit [DONE] sentinel.
+        const finishReason = (
+          parsed as {
+            choices?: Array<{ finish_reason?: string | null }>;
+          }
+        ).choices?.[0]?.finish_reason;
+        if (finishReason) {
+          sawTerminalSignal = true;
+        }
         yield parsed as OpenAIChatChunk;
         separatorIndex = buffer.search(/\r?\n\r?\n/);
       }
diff --git a/studio/frontend/src/features/chat/index.ts b/studio/frontend/src/features/chat/index.ts
index 7e894bb92e..a8b5fc23ad 100644
--- a/studio/frontend/src/features/chat/index.ts
+++ b/studio/frontend/src/features/chat/index.ts
@@ -17,6 +17,11 @@ export {
   type Preset,
 } from "./chat-settings-sheet";
 export { useChatRuntimeStore } from "./stores/chat-runtime-store";
+export {
+  preferFullToolOutput,
+  toolOutputKey,
+  useToolPaneScope,
+} from "./tool-output-scope";
 export { PermissionModeDropdown } from "./permission-mode-select";
 export { useChatSearchStore } from "./stores/chat-search-store";
 export { usePinnedChatsStore } from "./stores/pinned-chats-store";
diff --git a/studio/frontend/src/features/chat/runtime-provider.tsx b/studio/frontend/src/features/chat/runtime-provider.tsx
index 20fc979777..019d0bfd8a 100644
--- a/studio/frontend/src/features/chat/runtime-provider.tsx
+++ b/studio/frontend/src/features/chat/runtime-provider.tsx
@@ -54,6 +54,7 @@ import {
 } from "./open-document";
 import { AudioAttachmentAdapter } from "./audio-attachment-adapter";
 import { useChatRuntimeStore } from "./stores/chat-runtime-store";
+import { ToolPaneScopeContext, toolPaneScope } from "./tool-output-scope";
 import type { MessageRecord, ModelType, ThreadRecord } from "./types";
 import {
   deleteStoredChatThreads,
@@ -1347,26 +1348,33 @@ export function ChatRuntimeProvider({
 
   return (
     <AssistantRuntimeProvider runtime={runtime} aui={aui}>
-      <ActiveThreadSync
-        enabled={
-          modelType === "base" && !pairId && !newThreadNonce && !initialThreadId
-        }
-      />
-      <ThreadBackendAutosave modelType={modelType} pairId={pairId} />
-      <CancelRegistrar />
-      {initialThreadId && (
-        <ThreadAutoSwitch
-          threadId={initialThreadId}
-          syncActiveThreadId={syncActiveThreadId}
+      {/* Pane identity for the tool-output store maps: the adapter prefixes its
+          keys with this scope so concurrent panes with colliding tool ids
+          ("call_0") can't bleed live output into each other's cards. */}
+      <ToolPaneScopeContext.Provider value={toolPaneScope(modelType, pairId)}>
+        <ActiveThreadSync
+          enabled={
+            modelType === "base" &&
+            !pairId &&
+            !newThreadNonce &&
+            !initialThreadId
+          }
         />
-      )}
-      {!initialThreadId && newThreadNonce && (
-        <ThreadNewChatSwitch nonce={newThreadNonce} />
-      )}
-      {/* The view stays mounted (only CSS-hidden by RootLayout) while off-route
-          so assistant-ui keeps the run attached and the stream alive. Unmounting
-          it here aborts the in-flight generation. */}
-      {children}
+        <ThreadBackendAutosave modelType={modelType} pairId={pairId} />
+        <CancelRegistrar />
+        {initialThreadId && (
+          <ThreadAutoSwitch
+            threadId={initialThreadId}
+            syncActiveThreadId={syncActiveThreadId}
+          />
+        )}
+        {!initialThreadId && newThreadNonce && (
+          <ThreadNewChatSwitch nonce={newThreadNonce} />
+        )}
+        {/* The view stays mounted (only CSS-hidden) while off-route so the run
+            stays attached and the stream alive; unmounting aborts generation. */}
+        {children}
+      </ToolPaneScopeContext.Provider>
     </AssistantRuntimeProvider>
   );
 }
diff --git a/studio/frontend/src/features/chat/stores/chat-runtime-store.ts b/studio/frontend/src/features/chat/stores/chat-runtime-store.ts
index b70d2fbeab..2a81fe6ea8 100644
--- a/studio/frontend/src/features/chat/stores/chat-runtime-store.ts
+++ b/studio/frontend/src/features/chat/stores/chat-runtime-store.ts
@@ -701,6 +701,13 @@ type ChatRuntimeStore = {
    */
   webFetchToolsEnabled: boolean;
   toolStatus: string | null;
+  /** Live stdout/stderr from running tools, keyed by toolCallId. Transient:
+   *  appended by tool_output, cleared on tool_end or run end. */
+  toolLiveOutput: Record<string, string>;
+  /** Full live output of finished tools whose result was truncated for the
+   *  model, keyed by toolCallId. Set from tool_end; finished cards prefer it
+   *  over the truncated result. Session-transient. */
+  toolFullOutput: Record<string, string>;
   generatingStatus: string | null;
   autoHealToolCalls: boolean;
   nudgeToolCalls: boolean;
@@ -836,6 +843,13 @@ type ChatRuntimeStore = {
   setRagOcrScanned: (enabled: boolean) => void;
   setRagCaptionFigures: (enabled: boolean) => void;
   setToolStatus: (status: string | null) => void;
+  appendToolLiveOutput: (toolCallId: string, text: string) => void;
+  /** Clear one tool's live output, or all when no id is given. */
+  clearToolLiveOutput: (toolCallId?: string) => void;
+  /** Preserve a finished tool's full live-streamed output for display. */
+  setToolFullOutput: (toolCallId: string, text: string) => void;
+  /** Drop a stale preserved full output (a new run is reusing the id). */
+  clearToolFullOutput: (toolCallId: string) => void;
   setGeneratingStatus: (status: string | null) => void;
   setActiveDiffusionCanvas: (canvas: DiffusionCanvasFrame | null) => void;
   setAutoHealToolCalls: (enabled: boolean) => void;
@@ -1166,6 +1180,8 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set, get) => ({
   ragOcrScanned: loadBool(CHAT_RAG_OCR_KEY, DEFAULT_RAG_OCR),
   ragCaptionFigures: loadBool(CHAT_RAG_CAPTION_KEY, DEFAULT_RAG_CAPTION),
   toolStatus: null,
+  toolLiveOutput: {},
+  toolFullOutput: {},
   generatingStatus: null,
   activeDiffusionCanvas: null,
   autoHealToolCalls: true,
@@ -1415,6 +1431,8 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set, get) => ({
       // Only the per-session enable pill resets; source/mode/top_k persist.
       ragEnabled: false,
       toolStatus: null,
+      toolLiveOutput: {},
+      toolFullOutput: {},
       activeDiffusionCanvas: null,
       kvCacheDtype: null,
       loadedKvCacheDtype: null,
@@ -1638,6 +1656,43 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set, get) => ({
       return { ragCaptionFigures };
     }),
   setToolStatus: (toolStatus) => set({ toolStatus }),
+  appendToolLiveOutput: (toolCallId, text) =>
+    set((state) => ({
+      toolLiveOutput: {
+        ...state.toolLiveOutput,
+        [toolCallId]: (state.toolLiveOutput[toolCallId] ?? "") + text,
+      },
+    })),
+  setToolFullOutput: (toolCallId, text) =>
+    set((state) => ({
+      toolFullOutput: {
+        ...state.toolFullOutput,
+        [toolCallId]: text,
+      },
+    })),
+  clearToolFullOutput: (toolCallId) =>
+    set((state) => {
+      if (!(toolCallId in state.toolFullOutput)) {
+        return {};
+      }
+      const next = { ...state.toolFullOutput };
+      delete next[toolCallId];
+      return { toolFullOutput: next };
+    }),
+  clearToolLiveOutput: (toolCallId) =>
+    set((state) => {
+      if (toolCallId === undefined) {
+        return Object.keys(state.toolLiveOutput).length
+          ? { toolLiveOutput: {} }
+          : {};
+      }
+      if (!(toolCallId in state.toolLiveOutput)) {
+        return {};
+      }
+      const next = { ...state.toolLiveOutput };
+      delete next[toolCallId];
+      return { toolLiveOutput: next };
+    }),
   setActiveDiffusionCanvas: (activeDiffusionCanvas) =>
     set({ activeDiffusionCanvas }),
   setGeneratingStatus: (generatingStatus) => set({ generatingStatus }),
diff --git a/studio/frontend/src/features/chat/tool-output-scope.ts b/studio/frontend/src/features/chat/tool-output-scope.ts
new file mode 100644
index 0000000000..a7885a3916
--- /dev/null
+++ b/studio/frontend/src/features/chat/tool-output-scope.ts
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"use client";
+
+import { createContext, useContext } from "react";
+import type { ModelType } from "./types";
+
+/**
+ * Pane scope prefix for the transient tool-output store keys.
+ *
+ * Local GGUF tool ids are only unique within one response ("call_0", "call_1",
+ * ...), and panes stream concurrently (compare mode mounts two runtimes; the
+ * main view stays CSS-hidden off-route), so a bare id would let one pane's
+ * stdout bleed into another's same-id card. Derived from static props
+ * (`modelType` + `pairId`) shared by writer (adapter) and reader (components)
+ * via one `ChatRuntimeProvider`, so they can never disagree.
+ */
+export function toolPaneScope(modelType?: ModelType, pairId?: string): string {
+  return `${modelType ?? "base"}\u0000${pairId ?? ""}`;
+}
+
+export const ToolPaneScopeContext = createContext<string>(toolPaneScope());
+
+export function useToolPaneScope(): string {
+  return useContext(ToolPaneScopeContext);
+}
+
+/** Store key for the live/full tool output maps: pane scope + tool call id. */
+export function toolOutputKey(paneScope: string, toolCallId: string): string {
+  return `${paneScope}\u0000${toolCallId}`;
+}
+
+// Footer the backend appends when it truncates a result to protect the context
+// window (see backend tools._truncate). Marks where the result stops being a
+// copy of the stream, so it distinguishes "just truncated" from "carries
+// failure/exit status the stream never produced".
+const TRUNCATION_FOOTER_MARKER = "\n\n... (truncated";
+
+/**
+ * Whether the live stdout holds more real output than the model-visible
+ * `result` and should be preserved for the finished card. Shared by writer
+ * (retain?) and reader (display?) so they agree.
+ *
+ * True when the result is truncated, OR the stream is longer. Truncation can't
+ * fall back to length: a truncated result may be longer by byte count once its
+ * footer / `Exit code N:` / `__IMAGES__` blob is appended, yet the stream still
+ * holds more stdout. Also true when a short stream is absent from the result: a
+ * timed-out/cancelled tool returns only a status line, so length alone would
+ * drop the partial stdout the stream captured.
+ */
+export function shouldPreserveFullOutput(full: string, result: string): boolean {
+  if (!full) {
+    return false;
+  }
+  if (result.includes(TRUNCATION_FOOTER_MARKER)) {
+    return true;
+  }
+  if (full.length > result.length) {
+    return true;
+  }
+  // Stream no longer than the result, but a timed-out/cancelled tool's status
+  // line never echoes the captured stdout: preserve the stream whenever its
+  // content is absent from the result (trimmed to ignore trailing-newline drift).
+  const core = full.trim();
+  return core.length > 0 && !result.includes(core);
+}
+
+/**
+ * Pick what a finished python/terminal card shows. Prefer the fuller live
+ * stream over the truncated `result`, but the result can carry failure/exit
+ * text that never reached stdout ("Exit code N: ...", timeouts), so show the
+ * stream when the result is just a truncated prefix of it, else append the
+ * result so its status survives (and the copy button copies both).
+ */
+export function preferFullToolOutput(full: string, result: string): string {
+  if (!shouldPreserveFullOutput(full, result)) {
+    return result;
+  }
+  const marker = result.indexOf(TRUNCATION_FOOTER_MARKER);
+  const core = marker === -1 ? result : result.slice(0, marker);
+  if (!core || full === result || full.startsWith(core)) {
+    return full;
+  }
+  // Failed executions prefix the result (not the stream) with "Exit code N:\n",
+  // so `full.startsWith(core)` above misses and a plain append would duplicate
+  // the stdout. Re-attach just the exit prefix (and any missing-path hint) to
+  // the fuller stream so the status survives without duplicating stdout.
+  const exitMatch = core.match(/^(Exit code -?\d+:\n)([\s\S]*)$/);
+  if (exitMatch && full.startsWith(exitMatch[2])) {
+    const hint = result.match(/\nHint:[\s\S]*$/)?.[0] ?? "";
+    return `${exitMatch[1]}${full}${hint}`;
+  }
+  return `${full.replace(/\s+$/, "")}\n\n${result}`;
+}