com.blockether.vis.ext.channel-tui.chat — com.blockether/vis-channel-tui 0.1.1

TUI-side projections over the canonical in-process gateway.

On startup the TUI creates a fresh :tui gateway session by default. Pass --session-id ID or --resume to pick up an existing one. Session data is persisted in ~/.vis/vis.mdb so you can come back to it.

assistant-message clj

(assistant-message source)

(assistant-message source timestamp)

Create a structured assistant (vis) message with timestamp.

Accepts either:

• a Markdown source string -> the canonical input on the Markdown answer pipeline; IR is derived via vis/markdown->ir
• a canonical [:ir & nodes] vector -> IR is used as-is; raw Markdown is reconstructed via vis/render ir :markdown so the message still carries a :text field
• nil -> empty placeholder for unfilled answer slots

The message carries both: :text raw Markdown source (used by copy/export, FTS, plain views) :ir derived IR (used by the bubble layout walker)

attach! clj

(attach! session tid)

(attach! {:keys [id]} tid {:keys [on-chunk]})

Attach to a gateway turn tid already queued/running for session, blocking until it completes. Same result shape as turn! — drives TUI rendering for a busy-time submission the gateway queued (see gateway/state attach-turn-sync!).

discard-prewarmed-session! clj

(discard-prewarmed-session!)

Delete every warmed-but-unused TUI session and stop any in-flight warmups.

dispose! clj

(dispose! {:keys [id]})

Release the TUI's env handle. Session data stays in ~/.vis/vis.mdb so other consumers of the :tui channel (e.g. vis sessions tui, future inspectors) still see it.

empty-ir clj

Canonical empty IR — used as the placeholder when an answer slot is absent (e.g. resumed turns whose answer column is NULL because the turn never finished). Never feed nil or "" to the TUI render chokepoints; lift to empty-ir instead.

make-session clj

(make-session _provider-config)

(make-session provider-config opts)

Create a fresh :tui session. BLOCKING on a pool miss (builds inline).

Prefer make-session-async on the input thread; use this only where the caller genuinely needs the session id synchronously.

Optional opts map (second arity): :workspace-id pre-spawned workspace to pin the new session to. Omit and a trunk workspace is auto-minted by create-environment.

Returns {:id session-id :history []}.

make-session-async clj

(make-session-async provider-config)

(make-session-async provider-config opts)

Non-blocking make-session for the input thread. Never runs the cold env/runtime build on the caller's thread.

Returns one of: {:session {:id … :history []}} a warm session was ready — open it now. {:building fut} nothing warm — fut (a worker Future) resolves to {:id … :history []} once the cold build finishes. The caller opens an optimistic placeholder tab now and binds the real session when fut lands.

:workspace-id opts always build off-thread (never pooled), so they take the :building branch too.

prewarm-session! clj

(prewarm-session! provider-config)

Keep a small pool of empty :tui sessions warm on background workers.

The gateway facade intentionally couples the cheap session row with the expensive environment/runtime construction, so the practical prewarm unit is a real empty :tui session. make-session / make-session-async consume them atomically; shutdown deletes any left over.

Idempotent and safe to call from any thread: tops the pool up toward prewarm-pool-depth, counting both already-warm sessions and in-flight warmups, so racing callers never over-build.

render-answer clj

(render-answer ir)

Render canonical answer-IR ([:ir & nodes]) to the markdown string the TUI bubble renderer expects.

STRICT input contract: IR only. nil is accepted as a convenience for unfilled answer slots and renders as the empty string. Strings, Hiccup vectors, EDN values, etc. are programmer bugs — the IR boundary lives upstream (loop emits IR, persistence stores Nippy IR, resumed turns thaw to IR). Anything else throws with the offending type so the bug surfaces at the wrong call site, not silently in the bubble.

Dispatches via the TUI channel's :channel/messages-renderer-fn (core/render-for-tui) when registered; otherwise falls back to vis/render :markdown directly so unit tests that load this ns in isolation still work. Both paths share the same strict IR contract.

resume-session clj

(resume-session session-id)

Resume an existing gateway-managed session by id — ANY channel, so a conversation started in the web (or CLI) resumes here too. Accepts full UUID or unambiguous short UUID prefix. Returns {:id UUID :history [...]} with persisted messages.

turn! clj

(turn! session text)

(turn! {:keys [id]}
       text
       {:keys [on-chunk cancel-token reasoning-default extra-body turn-features
               workspace]})

Submit a user request through the canonical in-process gateway. Blocking. Returns {:answer [:ir ...]} or {:error str}.

user-message clj

(user-message text)

(user-message text timestamp)

Create a structured user message with timestamp. The user types raw markdown into the input box; we lift it to canonical IR via vis/markdown->ir immediately so the bubble layer (and every downstream consumer) sees the same shape it sees for assistant answers.

Unlike model answers, user input is line-oriented: every literal newline the user typed or pasted is intent (code, line-numbered dumps, stack traces). We lift with {:soft-break :hard} so bare newlines become [:br] and the bubble preserves the exact line structure instead of collapsing pasted lines into one wrapped wall of text (CommonMark prose soft-break semantics).

The message carries ONLY :ir — every consumer that needs a string projection computes it on demand (and caches the result client-side, e.g. via virtual.clj projection) instead of us eagerly rendering at construction.