Merge lane-app2: the chat experience and its multi-conversation state
Integrates eight commits of reviewed chat work: the Chat destination with several conversations, markdown transcripts, tool-call chips with an expandable INPUT/OUTPUT panel, edit diff cards, the composer's stop control, and approval cards. The automated resolver failed on this merge repeatedly (its own stages kept dying on the malformed-result defect), so it was integrated by hand. Integration decisions: - Pill geometry: main's tokens win. lane-app2 carried private duplicates of DESTINATION_ITEM_SIZE/GAP and a private DESTINATION_PILL_RESERVE, added before the geometry-token migration; those duplicates are dropped in favour of the theme tokens main already exports. - IME mode: kept lane-app2's adjustResize for the window, because the chat composer and the search field both raise the keyboard and the chat UI was reviewed with it. - Protocol and view-model constants: both sides' independent additions are kept. - ChatScreen now passes the compactLabel main's SlidingPaneStack gained, and the literals lane-app2 introduced before the token discipline are converted to five new named tokens (HAIRLINE_DP, ICON_BUTTON_SMALL_DP, TOOL_PANEL_MAX_WIDTH_DP, CHAT_TITLE_MAX_WIDTH_DP, CHAT_BUBBLE_MAX_WIDTH_DP) rather than allow-listed. Verified: assembleDebug plus the full Android unit suite (409 tests) pass, including the geometry enforcement test.
This commit is contained in:
@@ -0,0 +1,285 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Approval-card scaffolding: /connect WebSocket double that pushes a permission.
|
||||||
|
|
||||||
|
Two sessions: `ses_perm` hands out a pending `chat_permission` after a prompt so
|
||||||
|
the approval card can be answered (once/always/reject), and `ses_resolved` pushes
|
||||||
|
a frame the server already settled so the card must show the outcome with no
|
||||||
|
actions. Same wire shapes as the other stubs; test scaffolding only, never part
|
||||||
|
of the app.
|
||||||
|
"""
|
||||||
|
import base64
|
||||||
|
import hashlib
|
||||||
|
import itertools
|
||||||
|
import json
|
||||||
|
import socket
|
||||||
|
import struct
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
|
||||||
|
GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||||||
|
|
||||||
|
# Every prompt gets a fresh request id, so a new prompt is a new request rather
|
||||||
|
# than a re-push of an already-answered one.
|
||||||
|
REQUEST_SEQ = itertools.count(1)
|
||||||
|
|
||||||
|
PENDING_SESSION = "ses_perm"
|
||||||
|
RESOLVED_SESSION = "ses_resolved"
|
||||||
|
|
||||||
|
SESSIONS = [
|
||||||
|
{
|
||||||
|
"id": PENDING_SESSION,
|
||||||
|
"title": "Answer an approval",
|
||||||
|
"agent": "build",
|
||||||
|
"model": "deepseek-v4.1",
|
||||||
|
"directory": "/Users/alan/repos/pipelines",
|
||||||
|
"created_at": 1760620000000,
|
||||||
|
"updated_at": 1760620600000,
|
||||||
|
"busy": False,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"id": RESOLVED_SESSION,
|
||||||
|
"title": "Already resolved",
|
||||||
|
"agent": "build",
|
||||||
|
"model": "deepseek-v4.1",
|
||||||
|
"directory": "/Users/alan/repos/pipelines",
|
||||||
|
"created_at": 1760620000000,
|
||||||
|
"updated_at": 1760620600000,
|
||||||
|
"busy": False,
|
||||||
|
},
|
||||||
|
]
|
||||||
|
|
||||||
|
MESSAGES = {
|
||||||
|
PENDING_SESSION: [
|
||||||
|
{"id": "m1", "session_id": PENDING_SESSION, "role": "user",
|
||||||
|
"parts": [{"type": "text", "id": "m1t", "text": "Refactor the layout constants."}]},
|
||||||
|
{"id": "m2", "session_id": PENDING_SESSION, "role": "assistant",
|
||||||
|
"parts": [{"type": "text", "id": "m2t",
|
||||||
|
"text": "I need to edit `src/layout.kt`; approve the change to continue."}]},
|
||||||
|
],
|
||||||
|
RESOLVED_SESSION: [
|
||||||
|
{"id": "r1", "session_id": RESOLVED_SESSION, "role": "user",
|
||||||
|
"parts": [{"type": "text", "id": "r1t", "text": "Run the tests."}]},
|
||||||
|
{"id": "r2", "session_id": RESOLVED_SESSION, "role": "assistant",
|
||||||
|
"parts": [{"type": "text", "id": "r2t",
|
||||||
|
"text": "The shell command was approved from another client."}]},
|
||||||
|
],
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def _recv_exact(conn, n):
|
||||||
|
buf = b""
|
||||||
|
while len(buf) < n:
|
||||||
|
chunk = conn.recv(n - len(buf))
|
||||||
|
if not chunk:
|
||||||
|
raise EOFError
|
||||||
|
buf += chunk
|
||||||
|
return buf
|
||||||
|
|
||||||
|
|
||||||
|
def _handshake(conn):
|
||||||
|
data = b""
|
||||||
|
while b"\r\n\r\n" not in data:
|
||||||
|
chunk = conn.recv(4096)
|
||||||
|
if not chunk:
|
||||||
|
return False
|
||||||
|
data += chunk
|
||||||
|
headers = {}
|
||||||
|
for line in data.split(b"\r\n")[1:]:
|
||||||
|
if b":" in line:
|
||||||
|
k, v = line.split(b":", 1)
|
||||||
|
headers[k.strip().lower()] = v.strip()
|
||||||
|
key = headers.get(b"sec-websocket-key")
|
||||||
|
if not key:
|
||||||
|
return False
|
||||||
|
accept = base64.b64encode(hashlib.sha1(key + GUID.encode()).digest()).decode()
|
||||||
|
conn.sendall(("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\n"
|
||||||
|
"Connection: Upgrade\r\n"
|
||||||
|
f"Sec-WebSocket-Accept: {accept}\r\n\r\n").encode())
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
def _read_frame(conn):
|
||||||
|
b1, b2 = _recv_exact(conn, 2)
|
||||||
|
opcode = b1 & 0x0F
|
||||||
|
masked = b2 & 0x80
|
||||||
|
length = b2 & 0x7F
|
||||||
|
if length == 126:
|
||||||
|
length = struct.unpack(">H", _recv_exact(conn, 2))[0]
|
||||||
|
elif length == 127:
|
||||||
|
length = struct.unpack(">Q", _recv_exact(conn, 8))[0]
|
||||||
|
mask = _recv_exact(conn, 4) if masked else b""
|
||||||
|
payload = _recv_exact(conn, length) if length else b""
|
||||||
|
if masked:
|
||||||
|
payload = bytes(payload[i] ^ mask[i % 4] for i in range(len(payload)))
|
||||||
|
return opcode, payload
|
||||||
|
|
||||||
|
|
||||||
|
def _frame_text(text):
|
||||||
|
payload = text.encode()
|
||||||
|
header = bytearray([0x81])
|
||||||
|
n = len(payload)
|
||||||
|
if n < 126:
|
||||||
|
header.append(n)
|
||||||
|
elif n < 65536:
|
||||||
|
header.append(126)
|
||||||
|
header += struct.pack(">H", n)
|
||||||
|
else:
|
||||||
|
header.append(127)
|
||||||
|
header += struct.pack(">Q", n)
|
||||||
|
return bytes(header) + payload
|
||||||
|
|
||||||
|
|
||||||
|
def _frame_pong(payload):
|
||||||
|
"""Answer a client ping frame (opcode 0x9) with a pong (0xA).
|
||||||
|
|
||||||
|
OkHttp pings on its own schedule and drops the socket when no pong comes
|
||||||
|
back, so without this the app reconnects mid-drive.
|
||||||
|
"""
|
||||||
|
header = bytearray([0x8A])
|
||||||
|
n = len(payload)
|
||||||
|
if n < 126:
|
||||||
|
header.append(n)
|
||||||
|
elif n < 65536:
|
||||||
|
header.append(126)
|
||||||
|
header += struct.pack(">H", n)
|
||||||
|
else:
|
||||||
|
header.append(127)
|
||||||
|
header += struct.pack(">Q", n)
|
||||||
|
return bytes(header) + payload
|
||||||
|
|
||||||
|
|
||||||
|
class Session:
|
||||||
|
def __init__(self, conn):
|
||||||
|
self.conn = conn
|
||||||
|
self.lock = threading.Lock()
|
||||||
|
|
||||||
|
def send(self, message):
|
||||||
|
with self.lock:
|
||||||
|
self.conn.sendall(_frame_text(json.dumps(message)))
|
||||||
|
|
||||||
|
def send_event(self, session_id, kind, **fields):
|
||||||
|
frame = {"session_id": session_id, "kind": kind}
|
||||||
|
frame.update(fields)
|
||||||
|
self.send({"type": "chat_event", "chat_event": frame})
|
||||||
|
|
||||||
|
def push_permission(self, session_id, request_id, action, resources, message,
|
||||||
|
resolved=False, decision=""):
|
||||||
|
self.send({
|
||||||
|
"type": "chat_permission",
|
||||||
|
"chat_permission": {
|
||||||
|
"session_id": session_id,
|
||||||
|
"request_id": request_id,
|
||||||
|
"action": action,
|
||||||
|
"resources": resources,
|
||||||
|
"message": message,
|
||||||
|
"resolved": resolved,
|
||||||
|
"decision": decision,
|
||||||
|
"source": {"type": "tool", "message_id": "m2", "id": "call_1"},
|
||||||
|
},
|
||||||
|
})
|
||||||
|
|
||||||
|
def open_approval(self, session_id, request_id):
|
||||||
|
self.send_event(session_id, "step", step={"status": "started", "index": 1})
|
||||||
|
self.send_event(
|
||||||
|
session_id,
|
||||||
|
"text",
|
||||||
|
message_id="m3",
|
||||||
|
delta="Editing src/layout.kt — I need your approval before I write it.\n",
|
||||||
|
part={"type": "text", "id": "m3t"},
|
||||||
|
)
|
||||||
|
self.push_permission(
|
||||||
|
session_id,
|
||||||
|
request_id,
|
||||||
|
action="edit",
|
||||||
|
resources=["src/layout.kt"],
|
||||||
|
message="This rewrites src/layout.kt in your workspace. Review the change before allowing it.",
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def _respond(session, request):
|
||||||
|
kind = request.get("type")
|
||||||
|
print(f"<- {kind}", flush=True)
|
||||||
|
rid = request.get("id")
|
||||||
|
if kind == "ping":
|
||||||
|
session.send({"id": rid, "type": "pong", "time": "2026-10-16T15:00:00Z"})
|
||||||
|
elif kind == "chat_sessions":
|
||||||
|
session.send({"id": rid, "type": "chat_sessions", "chat_sessions": SESSIONS})
|
||||||
|
elif kind == "chat_messages":
|
||||||
|
body = request.get("chat_messages") or request.get("chat_query") or {}
|
||||||
|
session_id = body.get("session_id") or PENDING_SESSION
|
||||||
|
session.send({"id": rid, "type": "chat_messages",
|
||||||
|
"chat_messages": MESSAGES.get(session_id, [])})
|
||||||
|
if session_id == RESOLVED_SESSION:
|
||||||
|
# The server reports a request it has already settled: the card must
|
||||||
|
# state the outcome instead of offering once/always/reject.
|
||||||
|
session.push_permission(
|
||||||
|
session_id,
|
||||||
|
"req_resolved",
|
||||||
|
action="shell",
|
||||||
|
resources=["go test ./..."],
|
||||||
|
message="Another client already rejected this command.",
|
||||||
|
resolved=True,
|
||||||
|
decision="reject",
|
||||||
|
)
|
||||||
|
elif kind == "chat_prompt":
|
||||||
|
body = request.get("chat_prompt") or {}
|
||||||
|
session_id = body.get("session_id") or PENDING_SESSION
|
||||||
|
session.send({"id": rid, "type": "chat_prompt"})
|
||||||
|
threading.Thread(
|
||||||
|
target=session.open_approval,
|
||||||
|
args=(session_id, f"req_pending_{next(REQUEST_SEQ)}"),
|
||||||
|
daemon=True,
|
||||||
|
).start()
|
||||||
|
elif kind == "chat_reply":
|
||||||
|
body = request.get("chat_reply") or {}
|
||||||
|
print(f" decision={body.get('decision')} request={body.get('request_id')}", flush=True)
|
||||||
|
session.send({"id": rid, "type": "chat_reply"})
|
||||||
|
elif kind == "chat_interrupt":
|
||||||
|
session.send({"id": rid, "type": "chat_interrupt"})
|
||||||
|
else:
|
||||||
|
# Benign echo for pipelines/runs/status so the app's background loads do
|
||||||
|
# not surface an error while the chat is being driven.
|
||||||
|
session.send({"id": rid, "type": kind})
|
||||||
|
|
||||||
|
|
||||||
|
def _serve(conn):
|
||||||
|
session = Session(conn)
|
||||||
|
try:
|
||||||
|
if not _handshake(conn):
|
||||||
|
return
|
||||||
|
while True:
|
||||||
|
opcode, payload = _read_frame(conn)
|
||||||
|
if opcode == 0x8:
|
||||||
|
break
|
||||||
|
if opcode == 0x9:
|
||||||
|
with session.lock:
|
||||||
|
conn.sendall(_frame_pong(payload))
|
||||||
|
continue
|
||||||
|
if opcode != 0x1:
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
request = json.loads(payload.decode())
|
||||||
|
except Exception:
|
||||||
|
continue
|
||||||
|
_respond(session, request)
|
||||||
|
except (EOFError, OSError):
|
||||||
|
pass
|
||||||
|
finally:
|
||||||
|
conn.close()
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8799
|
||||||
|
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||||
|
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||||
|
server.bind(("0.0.0.0", port))
|
||||||
|
server.listen(8)
|
||||||
|
print(f"chat_stub_approval listening on 0.0.0.0:{port}", flush=True)
|
||||||
|
while True:
|
||||||
|
conn, _ = server.accept()
|
||||||
|
threading.Thread(target=_serve, args=(conn,), daemon=True).start()
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
@@ -4304,3 +4304,662 @@ Not verified in this pass: device frames of the populated panel, the empty resul
|
|||||||
and a selection navigating (the visual review owns the device, per the brief's
|
and a selection navigating (the visual review owns the device, per the brief's
|
||||||
device policy); the panel's pure logic is exercised by the unit tests and the
|
device policy); the panel's pure logic is exercised by the unit tests and the
|
||||||
compile only.
|
compile only.
|
||||||
|
|
||||||
|
## Chat destination and multiple conversations (16 Oct 2026)
|
||||||
|
|
||||||
|
The first Chat slice: the destination, the server session list and several
|
||||||
|
conversations held open at once. `android/` only; no new dependency (the
|
||||||
|
`material-icons-extended` icon is the declared one), no Pipelines server/Go/
|
||||||
|
installer/Docker file touched, no run started from the app, and the operator's
|
||||||
|
physical device was never used (`emulator-5556` only).
|
||||||
|
|
||||||
|
- **Pill.** The floating destination pill gains a Chat icon between Runs and
|
||||||
|
Settings (icons only, 48dp targets via the named `DESTINATION_ITEM_SIZE`/
|
||||||
|
`DESTINATION_ITEM_GAP` tokens, one non-wrapping `Row`), so it stays narrow and
|
||||||
|
clear of the reserved 88dp bottom inset however many destinations it holds.
|
||||||
|
The Search destination is owned by another lane and is not present on this
|
||||||
|
base; the pill is built to take it.
|
||||||
|
- **Brokered protocol.** `data/protocol/Chat.kt` mirrors `internal/protocol/chat.go`
|
||||||
|
field-for-field (sessions, create, query, prompt, messages/parts, event frames,
|
||||||
|
permission, reply); `Message` gains the optional `chat_*` payloads and
|
||||||
|
`PipelinesClient` now forwards *unsolicited* frames (chat_event/chat_permission)
|
||||||
|
to `events` instead of dropping them. `PipelinesRepository` exposes the typed
|
||||||
|
chat calls.
|
||||||
|
- **Multi-chat model.** `ui/chat/ChatStore.kt` is an Android-free state holder:
|
||||||
|
every open chat keeps its own conversation, running flag, composer draft and
|
||||||
|
scroll position; `open`/`activate` report when history must be (re-)fetched so
|
||||||
|
a running session re-syncs on return instead of showing a stale copy; a
|
||||||
|
server frame is applied to its chat whether or not it is on screen. `busy`
|
||||||
|
sessions render read-only and the composer refuses to write to them.
|
||||||
|
- **Surface.** `ui/chat/ChatScreen.kt` reuses the shared adaptive
|
||||||
|
`SlidingPaneStack` (session list → conversation): the list shows each session's
|
||||||
|
running/busy/read-only status, an open-chat strip switches between several
|
||||||
|
conversations in one tap (with an optional X to close one), and the
|
||||||
|
conversation is a bottom-anchored transcript of user bubbles, secondary
|
||||||
|
reasoning, assistant text and tool-call chips that expand to INPUT
|
||||||
|
(pretty-printed JSON) / OUTPUT (monospace, via the shared `CodeBlock`).
|
||||||
|
"New chat" creates a server session and opens it. Closing a chat *is* provided
|
||||||
|
(the chip X); it removes only that chat.
|
||||||
|
- **Messages sent to a chat are optimistic** (the bubble shows immediately); the
|
||||||
|
live delta/streaming pass is the next slice.
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks` →
|
||||||
|
`BUILD SUCCESSFUL`, **229 tests, 0 failures** (new `MultiChatStateTest`:
|
||||||
|
switching preserves each conversation, a running session re-syncs on return,
|
||||||
|
drafts and scroll are per chat, a busy session is read-only, background events
|
||||||
|
land on their own chat; new `ChatProtocolTest` for the wire shapes; new
|
||||||
|
`ChatFormatTest`).
|
||||||
|
- The debug APK was installed on `emulator-5556` (`FoldB_API_36`, narrow
|
||||||
|
`wm size 1080x2340` @420) and driven with `uiautomator dump`/`input tap`;
|
||||||
|
captures were validated with `android/scripts/capture_png.sh -s emulator-5556`:
|
||||||
|
the pill with the Chat destination (`01_pill_chat`), the session list
|
||||||
|
(`02_chat_list`, `05_chat_list_one_open`, `07_chat_list_two_open`), two chats
|
||||||
|
with different conversations (`03_chat_alpha` and `06_chat_beta`), a tool chip
|
||||||
|
expanded to INPUT/OUTPUT (`04_chat_alpha_tool_expanded`), a read-only busy
|
||||||
|
session with a disabled composer (`08_chat_readonly`) and a per-chat draft
|
||||||
|
preserved across a switch (`10_draft_preserved`). `adb -s emulator-5556 logcat
|
||||||
|
-d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
|
||||||
|
- **The deployed Pipelines server predates chat** (verified: a `chat_sessions`
|
||||||
|
request answers `unknown command: chat_sessions`), and the server-side chat
|
||||||
|
broker is a separate lane. The on-emulator sweep therefore drove the client
|
||||||
|
against `chat_stub.py`, a minimal `/connect` WebSocket double that speaks the
|
||||||
|
exact `internal/protocol/chat.go` JSON, so the screenshots show real client
|
||||||
|
rendering of the documented wire contract, not the production service.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,261,008 bytes, sha256
|
||||||
|
`aa167617c830fd7249eedf457959ef7e99b553769ed4ab82a3af6b4e8cb98ed3`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/119/1/pipelines-debug-wip-e5bde98.apk`;
|
||||||
|
`curl -I http://10.0.0.249:8080/artifacts/119/1/pipelines-debug-wip-e5bde98.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18261008`; a streamed `GET | shasum -a 256` matched.
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (not deployed and out of
|
||||||
|
this lane's scope), a genuinely running session's re-sync against OpenCode
|
||||||
|
(covered by the model test, not live), and streaming/stop/approval/attachments,
|
||||||
|
which are later slices.
|
||||||
|
|
||||||
|
### Review follow-ups (16 Oct 2026, implementer pass)
|
||||||
|
|
||||||
|
Addressing the reviewer's findings on the slice above, still `android/` only.
|
||||||
|
|
||||||
|
- **Shared part upsert (duplication blocker).** `ChatStore.applyDelta` and
|
||||||
|
`applyTool` were the same message/part upsert twice. Both now call one private
|
||||||
|
`upsertPart(frame, partId) { existing -> … }`; the delta appends to the existing
|
||||||
|
text, the tool replaces the part, and neither can drift. `event()` and the new
|
||||||
|
`permission()` share one `ensureThread()` placeholder creator.
|
||||||
|
- **Diff cards (task gap).** The research report's edit view (`_CodeRun` /
|
||||||
|
`_DiffView`, §1.3) is now reproduced: an `edit`-family tool call renders a diff
|
||||||
|
card. `ChatFormat.toolEditDiff` derives an LCS line diff from the arguments'
|
||||||
|
`oldString`/`newString` — the brokered protocol has **no** diff field (research
|
||||||
|
§2.5), so it is synthesised, never silently dropped. The collapsed chip shows
|
||||||
|
the file and the `+N -M` stat; expanding shows the green/red monospace lines
|
||||||
|
(the app's own success/failure hues, not new literals).
|
||||||
|
- **One read-only rule (divergent code).** `sessionReadOnly` was dead (only its
|
||||||
|
own test called it) and disagreed with the UI's `ChatThread.readOnly = busy` for
|
||||||
|
a locally-running busy session. The helper is deleted and `ChatThread.readOnly`
|
||||||
|
is now `busy && !running`, the same precedence `sessionStatusLabel` uses: a turn
|
||||||
|
we started is `Running` and writable, not read-only.
|
||||||
|
- **`chatReply` / approval now reachable (unused API).** `observeChatEvents`
|
||||||
|
forwards `chat_permission` into `ChatStore.permission` instead of dropping it,
|
||||||
|
the conversation shows an approval bar (action, resources, Allow once / Always /
|
||||||
|
Deny) and `AppViewModel.replyChatPermission` answers through `chatReply`.
|
||||||
|
- **Stop control fixed (found while tracing read-only).** While a turn ran the
|
||||||
|
composer's red stop button was wired to `onSend`, so it sent the draft instead
|
||||||
|
of interrupting; it now calls `stopChat`.
|
||||||
|
- **Evidence gap closed.** The previous checklist cited `09` (new chat) but no
|
||||||
|
`09_*` file existed; this pass captures `09_new_chat.png` (the New-chat
|
||||||
|
conversation), plus `11_diff_card.png` and `12_permission_bar.png` for the two
|
||||||
|
new surfaces.
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
|
||||||
|
SUCCESSFUL`; the JUnit XML totals **233 tests, 0 failures, 0 errors, 0
|
||||||
|
skipped** (new `toolEditDiffMarksOnlyChangedLinesAndCountsThem`,
|
||||||
|
`toolEditDiffIsNullForNonEdits`, `locallyRunningBusyChatStaysWritable`,
|
||||||
|
`permissionIsStoredUntilAnswered`).
|
||||||
|
- The debug APK was installed on `emulator-5556` only and driven with
|
||||||
|
`uiautomator dump`/`input tap`; captures validated with
|
||||||
|
`android/scripts/capture_png.sh -s emulator-5556`: the new-chat conversation
|
||||||
|
(`09_new_chat`), the derived diff (`11_diff_card`, showing
|
||||||
|
`context / - val gap = 4.dp / + val gap = 6.dp / + val inset = 2.dp` under a
|
||||||
|
`src/layout.kt +2 -1` chip) and the approval bar (`12_permission_bar`). Tapping
|
||||||
|
**Allow once** cleared the bar through `chat_reply`. `adb -s emulator-5556
|
||||||
|
logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime`. Driven against the
|
||||||
|
test-double stub (the deployed server still predates chat).
|
||||||
|
- **APK publish.** `app-debug.apk` (18,228,844 bytes, sha256
|
||||||
|
`db240fc2fc295c5ab50530f9d8cefae908f307a3115b54ce9f6d713e05643b87`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/119/3/pipelines-debug-wip-e5bde98.apk`.
|
||||||
|
|
||||||
|
Still not verified: the live brokered server (separate lane), streaming against
|
||||||
|
real OpenCode, and attachments — unchanged from the pass above.
|
||||||
|
|
||||||
|
## Conversation markdown rendering (16 Oct 2026)
|
||||||
|
|
||||||
|
The assistant's `text` part was rendered as one plain `Text`; it is now rendered
|
||||||
|
as markdown, matching the reference experience (research report Part 1 §1.2).
|
||||||
|
`android/` only; no new dependency (still just the declared
|
||||||
|
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
|
||||||
|
no run started from the app, and `emulator-5556` only (lane A's `emulator-5554`
|
||||||
|
was never addressed).
|
||||||
|
|
||||||
|
- **Parser.** `ui/chat/Markdown.kt` adds a small, dependency-free CommonMark
|
||||||
|
subset. It is pure Kotlin (no Compose, no transport) so it is unit-testable:
|
||||||
|
paragraphs (soft-wrapped lines join with a space), `#`..`######` headings,
|
||||||
|
fenced code (``` ``` / `~~~`, with the info string as the language), block
|
||||||
|
quotes, bullet and ordered lists, `|` tables (with a `---` delimiter row),
|
||||||
|
thematic rules, and inline code / bold / italic / `[label](url)` /
|
||||||
|
bare-`http(s)://` autolinks. Underscore emphasis needs word boundaries so
|
||||||
|
`snake_case` is never italicised. Anything outside the subset renders as plain
|
||||||
|
text, never dropped.
|
||||||
|
- **Renderer.** The same file turns the blocks into themed, selectable Compose
|
||||||
|
content: fenced code reuses the shared `CodeBlock`, so the whole-block copy
|
||||||
|
action is the existing one (label = the fence language, `code` when absent);
|
||||||
|
tables are a bordered grid with a bold header and equal-weight wrapping cells;
|
||||||
|
links use `LinkAnnotation.Url`, so they are tap-openable and styled from the
|
||||||
|
scheme; inline code and headings use the shared type roles
|
||||||
|
(`pipelinesText()`), not ad-hoc sizes. `ChatScreen.MessagePart` now calls
|
||||||
|
`MarkdownText(part.text)` for `PART_TEXT`; the assistant message stays one
|
||||||
|
`SelectionContainer`, so all of it remains selectable and the bounded code
|
||||||
|
block/table keep long content inside the bubble. Geometry reuses the chat
|
||||||
|
tokens (`CHAT_ITEM_GAP`, promoted from `private` to `internal`); only the
|
||||||
|
quote-bar width and table border, which had no token, are new named constants.
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
|
||||||
|
SUCCESSFUL`; the JUnit XML totals **243 tests, 0 failures, 0 errors, 0
|
||||||
|
skipped** (new `MarkdownTest`: fences keep their language, an unterminated
|
||||||
|
fence still yields code, soft-wrapped paragraphs join, headings/rules parse by
|
||||||
|
level, bullet/ordered lists, table header/rows, inline code/bold/italic/link,
|
||||||
|
bare-URL autolink trims trailing punctuation, `snake_case` is not emphasis,
|
||||||
|
empty source → no blocks).
|
||||||
|
- The debug APK was installed on `emulator-5556` only and driven against a
|
||||||
|
stdlib `/connect` WebSocket double serving a fixed history; capture was
|
||||||
|
validated with `android/scripts/capture_png.sh -s emulator-5556`:
|
||||||
|
`chat_markdown_conversation.png` shows the bottom-anchored transcript with the
|
||||||
|
user bubble, the secondary reasoning line, body markdown with inline code and
|
||||||
|
an underlined link, a `kotlin` fenced code block with its copy action, and the
|
||||||
|
bordered `Surface | Role` table. `adb -s emulator-5556 logcat -d` held 0
|
||||||
|
`FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,076,412 bytes, sha256
|
||||||
|
`bb290a7f42a3b28e613098dfffea438c34a5332081cffc6a2fbc0d275c207f68`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/124/1/pipelines-debug-wip-0718f5b.apk`;
|
||||||
|
`HEAD` is `0718f5b` and a streamed `curl | shasum -a 256` of
|
||||||
|
`http://10.0.0.249:8080/artifacts/124/1/pipelines-debug-wip-0718f5b.apk`
|
||||||
|
matched.
|
||||||
|
|
||||||
|
Not verified: the live brokered server (separate lane), streaming against real
|
||||||
|
OpenCode, and attachments — unchanged from the passes above. The markdown subset
|
||||||
|
is intentionally smaller than full CommonMark (no HTML, no reference links, no
|
||||||
|
nested lists, no strikethrough).
|
||||||
|
|
||||||
|
## Streaming replies (16 Oct 2026)
|
||||||
|
|
||||||
|
The live delta/streaming pass promised by the first slice. `android/` only; no new
|
||||||
|
dependency (still just the declared `material-icons-extended`), no Pipelines
|
||||||
|
server/Go/installer/Docker file touched, no run started from the app, and
|
||||||
|
`emulator-5556` only (lane A's `emulator-5554` was never addressed).
|
||||||
|
|
||||||
|
- **Turn lifecycle in the model.** `ChatStore` now owns `ChatThread.runningSince`
|
||||||
|
and one private `setRunning` transition, so a turn that begins is stamped with
|
||||||
|
the wall clock and settling clears it; `ChatThread.elapsedMillis(now)` is the one
|
||||||
|
pure derivation the indicator and its test share. `event` already appended
|
||||||
|
`text`/`reasoning` deltas to the target part and upserted tool parts, wherever the
|
||||||
|
frame's chat sits in the open order.
|
||||||
|
- **Running indicator.** The transcript's indicator shows the spinner, `Working…`
|
||||||
|
and the live elapsed time (ticked once a second, never per frame, through the
|
||||||
|
shared `formatDuration`). Its tick loop is keyed on the turn's start and stops the
|
||||||
|
moment the turn settles, and the elapsed value keeps counting across a chat
|
||||||
|
switch because it lives on the thread, not the composable.
|
||||||
|
- **Follow the stream.** The transcript hard-jumps to the newest item while a turn
|
||||||
|
runs — a fast-growing reply outruns an animation — unless the operator has
|
||||||
|
scrolled up to read; returning to the end resumes following. Consuming the list
|
||||||
|
state's `interactionSource.interactions` (`DragInteraction.Start`/`Stop`/`Cancel`)
|
||||||
|
distinguishes a user drag from the programmatic jump, so the jump never un-sticks
|
||||||
|
the view.
|
||||||
|
- **Reconnect resync.** `AppViewModel.observeConnection` re-fetches every open
|
||||||
|
chat's history whenever the socket transitions to `Connected`, after
|
||||||
|
`ChatStore.streamResumed()` settles each running thread (a still-live stream
|
||||||
|
re-asserts `running` on its next frame, so no stale `Working…` sticks). The
|
||||||
|
resync *replaces* the conversation wholesale, so a gap can neither duplicate nor
|
||||||
|
drop text.
|
||||||
|
- **Failure settle.** A server-pushed `error` frame carries no session id (the
|
||||||
|
brokered protocol cannot attribute it), so `ChatStore.streamError` settles the
|
||||||
|
sole running chat — or the active one when several are in flight — and keeps the
|
||||||
|
server's text; with nothing running it is ignored. The prompt-call failure path
|
||||||
|
already settled the turn and is unchanged.
|
||||||
|
- **Non-blocking.** Unsolicited frames reach the UI through the client's bounded
|
||||||
|
`SharedFlow` (`tryEmit` from the socket thread, `DROP_OLDEST` capacity 256), so a
|
||||||
|
slow collector never blocks the read loop; each mutation touches only its chat and
|
||||||
|
the `LazyColumn` keys limit recomposition to the changed item.
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17 target, Gradle 9.7.1,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the JUnit
|
||||||
|
XML totals **248 tests, 0 failures, 0 errors, 0 skipped** (new `ChatStreamTest`:
|
||||||
|
a delta sequence grows the rendered text and toggles the running indicator, the
|
||||||
|
elapsed time comes from the turn's own start and a repeated start keeps it,
|
||||||
|
`streamResumed` settles every open chat and returns them for re-fetch,
|
||||||
|
`streamError` settles the running turn with the server's text and is ignored with
|
||||||
|
nothing running).
|
||||||
|
- The debug APK was installed on `emulator-5556` only and driven with
|
||||||
|
`uiautomator dump`/`input tap` against `.stream_check/stream_stub.py` (a stdlib
|
||||||
|
`/connect` WebSocket double that streams `chat_event` frames; test scaffolding,
|
||||||
|
not the app — the deployed server still predates chat). Captures were validated
|
||||||
|
with `android/scripts/capture_png.sh -s emulator-5556`: a mid-stream reply with
|
||||||
|
the growing transcript and the indicator at `Working… · 1s`
|
||||||
|
(`chat_stream_01_early`) and `Working… · 4s` with the list followed to the newest
|
||||||
|
line (`chat_stream_02_mid`); the settled turn with the completed `bash 340ms`
|
||||||
|
tool chip, no indicator and the send control restored (`chat_stream_03_settled`);
|
||||||
|
and, after a mid-stream drag up, the transcript **staying** where the operator
|
||||||
|
left it while the turn still ran (`chat_stream_04_scrolled_up`). `adb -s
|
||||||
|
emulator-5556 logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime`
|
||||||
|
during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,262,465 bytes, sha256
|
||||||
|
`ef435b662e6f7e7467b5ae25b69fb24f8904334af204224aad00bfd76879a84e`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/126/1/pipelines-debug-wip-d7f6500.apk`;
|
||||||
|
`curl -I http://10.0.0.249:8080/artifacts/126/1/pipelines-debug-wip-d7f6500.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18262465`, and a streamed `GET | shasum -a 256` matched.
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged. `:app:lintDebug` could not run
|
||||||
|
in this environment: the Gradle JVM reports `25.0.4.1`, a version string the AGP
|
||||||
|
8.7.2 lint (IntelliJ `JavaVersion`) rejects, so lint fails before analysing the
|
||||||
|
tree; this is environmental and unrelated to the change.
|
||||||
|
|
||||||
|
## Tool-call chips and the expandable panel (16 Oct 2026)
|
||||||
|
|
||||||
|
The tool-call surface now matches the reference chat's `_ToolCalls`/`_ToolChip`
|
||||||
|
and `_buildPanel` (research §1.3) more closely. `android/` only; no new
|
||||||
|
dependency (still just the declared `material-icons-extended`), no Pipelines
|
||||||
|
server/Go/installer/Docker file touched, no run started from the app, and
|
||||||
|
`emulator-5556` only (lane A's `emulator-5554` was never addressed).
|
||||||
|
|
||||||
|
- **Grouped chips.** A run of consecutive `tool` parts in one assistant turn is
|
||||||
|
now one `FlowRow` of compact chips (`ToolCalls`/`ToolChip`), so the turn's calls
|
||||||
|
sit together and wrap instead of each taking a full-width row. Each chip keeps
|
||||||
|
its kind icon, label (the edited file for an `edit`), `+N -M` diff stat,
|
||||||
|
duration and running spinner.
|
||||||
|
- **Overlay panel, scroll preserved.** Tapping a chip opens its INPUT/OUTPUT
|
||||||
|
panel as a `Popup` anchored to that chip, not as inline content. The former
|
||||||
|
inline panel re-flowed the transcript (a short chat visibly jumped); the popup
|
||||||
|
is outside the list layout, so opening, failing or dismissing it never moves the
|
||||||
|
conversation's scroll anchor. `ToolPanelPositionProvider` places it below the
|
||||||
|
chip, flips it above when there is no room, and keeps it inside the window
|
||||||
|
margins. The panel is dismissible by its own X or by tapping outside, and its
|
||||||
|
INPUT and OUTPUT blocks carry the shared `CodeBlock` copy action.
|
||||||
|
- **Visible failure.** An `error` tool call is now unmistakable: an
|
||||||
|
error-tinted chip with an `ErrorOutline` icon (`toolFailed`), and its panel
|
||||||
|
shows an ERROR block with the tool's error text (`ChatFormat.toolFailed`).
|
||||||
|
- **Diff cards preserved.** An `edit`-family chip still expands to the synthesised
|
||||||
|
green/red diff (`toolEditDiff`/`DiffView`), unchanged.
|
||||||
|
|
||||||
|
Evidence (macOS, Gradle 9.7.1 `--offline`, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
|
||||||
|
SUCCESSFUL`; the JUnit XML totals **252 tests, 0 failures, 0 errors, 0
|
||||||
|
skipped** (new `toolFailedOnlyForTheErrorStatus`, and
|
||||||
|
`ToolPanelPositionProviderTest`: below-the-chip, flip-above and margin-clamp
|
||||||
|
placement).
|
||||||
|
- The debug APK was installed on `emulator-5556` only and driven against
|
||||||
|
`.tool_calls_check/chat_stub_tools.py` (a stdlib `/connect` WebSocket double
|
||||||
|
serving the documented `internal/protocol/chat.go` JSON; test scaffolding, not
|
||||||
|
the app). Captures were validated with `android/scripts/capture_png.sh -s
|
||||||
|
emulator-5556`: `01_tools_collapsed.png` (the completed `bash 340ms` and
|
||||||
|
`src/layout.kt +2 -2 300ms` chips grouped), `02_tools_expanded.png` (the bash
|
||||||
|
chip expanded to INPUT pretty JSON + OUTPUT monospace with the transcript behind
|
||||||
|
it unmoved — the chips keep the same on-screen position), and
|
||||||
|
`03_error_chip_collapsed.png`/`04_error_chip_expanded.png` (the failed `shell`
|
||||||
|
chip in the error container and its panel INPUT + ERROR text). Tapping outside
|
||||||
|
the panel dismissed it with the chips still in place. `adb -s emulator-5556
|
||||||
|
logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,262,465 bytes, sha256
|
||||||
|
`160f10ea8a2dc80364bb7f38596d50d08557ccce01f99705b93a8b9bc9216c27`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/129/1/pipelines-debug-wip-d7f6500.apk`;
|
||||||
|
`curl -I http://10.0.0.249:8080/artifacts/129/1/pipelines-debug-wip-d7f6500.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18262465`, and a streamed `GET | shasum -a 256` matched.
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged from the passes above.
|
||||||
|
|
||||||
|
## Tool-call review fixes (16 Oct 2026)
|
||||||
|
|
||||||
|
Two findings from the tool-call slice review, both in `android/`, under the same
|
||||||
|
constraints as above (no new dependency beyond the declared
|
||||||
|
`material-icons-extended`, no Pipelines server/Go/installer/Docker file touched,
|
||||||
|
no run started from the app, `emulator-5556` only).
|
||||||
|
|
||||||
|
- **One elapsed derivation.** `ChatScreen.rememberElapsedMillis` re-derived the
|
||||||
|
running turn's elapsed time by subtracting the start itself, duplicating the
|
||||||
|
tested `ChatThread.elapsedMillis` and contradicting the two KDocs that claimed
|
||||||
|
the indicator shared the model's derivation. The composable now ticks a
|
||||||
|
`rememberElapsedNow(runningSince)` wall clock (once a second, and only while
|
||||||
|
the turn lives) and reads `thread.elapsedMillis(now)`, so the model and the UI
|
||||||
|
cannot drift.
|
||||||
|
- **No per-frame allocation.** `ToolCalls` keyed its open-panel `remember` on
|
||||||
|
`parts.map { it.id }`, allocating a list on every streaming recomposition. The
|
||||||
|
key is unnecessary — an id no longer among the calls simply matches nothing —
|
||||||
|
so `openId` is plain remembered state and a streaming rebuild no longer
|
||||||
|
allocates a key list.
|
||||||
|
|
||||||
|
Evidence (macOS, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
|
||||||
|
SUCCESSFUL`; the JUnit XML totals **252 tests, 0 failures, 0 errors, 0
|
||||||
|
skipped**.
|
||||||
|
- The rebuilt debug APK was installed on `emulator-5556` only and driven against
|
||||||
|
`.tool_calls_check/chat_stub_tools.py` and `chat_stub_error.py` (stdlib
|
||||||
|
`/connect` WebSocket doubles serving the documented `internal/protocol/chat.go`
|
||||||
|
JSON; test scaffolding, not the app). Captures were validated with
|
||||||
|
`android/scripts/capture_png.sh -s emulator-5556` into `.tool_calls_fix/`:
|
||||||
|
`01_tools_collapsed.png` (the completed `bash 340ms` and `src/layout.kt +2 -2
|
||||||
|
300ms` chips grouped), `02_tools_expanded.png` (the bash chip's INPUT pretty
|
||||||
|
JSON + OUTPUT monospace), `04_diff_card.png` (the edit chip's synthesised
|
||||||
|
green/red diff card), `03_dismissed_outside.png` (tapping outside dismissed the
|
||||||
|
panel with both chips at the same on-screen bounds), and
|
||||||
|
`05_error_chip_collapsed.png`/`06_error_chip_expanded.png` (the failed `shell`
|
||||||
|
chip in the error container, with a `Failed tool call` description, and its
|
||||||
|
panel INPUT + ERROR text). `adb -s emulator-5556 logcat -d` held 0 `FATAL
|
||||||
|
EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,219,766 bytes, sha256
|
||||||
|
`b607a879ce2f2ac324fe6fa254918a456337c678abc1781bb79a05d88d539984`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/129/3/pipelines-debug-wip-d7f6500.apk`;
|
||||||
|
`curl -I http://10.0.0.75:8080/artifacts/129/3/pipelines-debug-wip-d7f6500.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18219766`, and a streamed `GET | shasum -a 256` matched. This
|
||||||
|
supersedes the `129/1` publish above: it is built from the current source, so
|
||||||
|
the change is in the served artifact (a fresh rebuild can still differ in
|
||||||
|
`classes5.dex` — the reproducibility caveat recorded in review stands).
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged from the passes above.
|
||||||
|
`:app:lintDebug` still cannot run here (the Gradle JVM's `25.0.4.1` version
|
||||||
|
string is rejected by AGP 8.7.2 lint), unchanged from the slice above.
|
||||||
|
|
||||||
|
## Tool-call review fixes, second pass (16 Oct 2026)
|
||||||
|
|
||||||
|
Three findings from the tool-call slice's second review, all in `android/` under
|
||||||
|
the same constraints (no new dependency beyond the declared
|
||||||
|
`material-icons-extended`, no Pipelines server/Go/installer/Docker file touched, no
|
||||||
|
run started from the app, `emulator-5556` only).
|
||||||
|
|
||||||
|
- **A failed edit call shows its error.** The panel only rendered the diff for an
|
||||||
|
`edit`-family call, because the `diff != null` branch sat above the `failed`
|
||||||
|
check, so a *failed* edit showed no error text. The ERROR block is now emitted
|
||||||
|
whenever `toolFailed`, alongside the diff when one exists; a failed non-edit call
|
||||||
|
keeps INPUT + ERROR, and a successful edit still shows the diff alone.
|
||||||
|
- **The error message, not the partial output.** `ChatFormat.toolOutputText`
|
||||||
|
returned non-blank `state.content` before it considered `state.error`, and that
|
||||||
|
text fed the ERROR block, so a failed call carrying both showed its partial
|
||||||
|
output under the ERROR heading. The failed call's text now comes from the new
|
||||||
|
`toolErrorText`, which prefers the server's message and falls back to the output
|
||||||
|
text only when the failure carries none; `toolOutputText` is the OUTPUT
|
||||||
|
derivation again.
|
||||||
|
- **README mechanism corrected.** The follow-the-stream bullet claimed a
|
||||||
|
`snapshotFlow` on the list's scroll state; the code consumes
|
||||||
|
`listState.interactionSource.interactions` (`DragInteraction.Start`/`Stop`/`Cancel`),
|
||||||
|
as the bullet now says.
|
||||||
|
|
||||||
|
Evidence (macOS, Gradle 9.7.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
|
||||||
|
JUnit XML totals **253 tests, 0 failures, 0 errors, 0 skipped** (the failed-text
|
||||||
|
helper split into `toolOutputFallsBackToNoOutput` and
|
||||||
|
`toolErrorPrefersTheMessageOverPartialOutput`, which asserts the message wins over
|
||||||
|
a failed call's partial output).
|
||||||
|
- The rebuilt debug APK was installed on `emulator-5556` only and driven against
|
||||||
|
`.tool_calls_fix2/chat_stub_failed_edit.py` (the review tool stub plus a failed
|
||||||
|
`edit` call with `oldString`/`newString` and a failed `bash` call carrying both
|
||||||
|
partial output and an error; stdlib `/connect` WebSocket double, test
|
||||||
|
scaffolding, not the app). Captures were validated with
|
||||||
|
`android/scripts/capture_png.sh -s emulator-5556` into `.tool_calls_fix2/`:
|
||||||
|
`04_failed_edit_expanded.png` shows the failed edit chip's diff *and* its ERROR
|
||||||
|
block (`oldString not found in src/layout.kt`), and
|
||||||
|
`06_failed_bash_expanded.png` shows the failed bash call's INPUT + ERROR
|
||||||
|
(`exit status 2: src/nope.kt: No such file`), the error text — not the partial
|
||||||
|
output — under the ERROR heading. `uiautomator dump` confirms the same nodes;
|
||||||
|
`adb -s emulator-5556 logcat -d` held 0 `FATAL EXCEPTION` and 0 `E
|
||||||
|
AndroidRuntime` during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,219,360 bytes, sha256
|
||||||
|
`4522aa62c8a3a59033aa2cca8b7fba65267dbdde473284585eaae47f03aeda2f`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/129/5/pipelines-debug-wip-d7f6500.apk`;
|
||||||
|
`curl -I http://10.0.0.249:8080/artifacts/129/5/pipelines-debug-wip-d7f6500.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18219360`, and a streamed `GET | shasum -a 256` matched. This
|
||||||
|
supersedes the `129/3` publish above: it is rebuilt from the current source, so
|
||||||
|
the fix is in the served artifact (the `classes5.dex` reproducibility caveat
|
||||||
|
recorded in review stands).
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged from the passes above.
|
||||||
|
|
||||||
|
## Edit diffs: file name, stat and large-edit summarisation (16 Oct 2026)
|
||||||
|
|
||||||
|
The edit diff card already derived its lines, but three things the task calls for
|
||||||
|
were missing or wrong. `android/` only; no new dependency (still just the declared
|
||||||
|
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
|
||||||
|
no run started from the app, and `emulator-5556` only (lane A's `emulator-5554`
|
||||||
|
was never addressed).
|
||||||
|
|
||||||
|
- **The file name and `+N -M` are on the card, not just the chip.** The expanded
|
||||||
|
panel header showed the tool name (`edit`); it now shows the edited file (as the
|
||||||
|
chip already did) and the shared green/red `DiffStat`, so the diff names its file
|
||||||
|
and its counts wherever it is read.
|
||||||
|
- **Very large edits are summarised, not flooded.** A diff longer than
|
||||||
|
`MAX_RENDERED_DIFF_LINES` (200) kept *every* line — the >400-line fallback
|
||||||
|
rendered `old + new` in full, thousands of `Text` nodes in a scrolling `Column`
|
||||||
|
on a phone. `ChatFormat.toolEditDiff` now keeps the first 200 lines and carries
|
||||||
|
the rest in the new `ToolDiff.omitted`; `DiffView` prints
|
||||||
|
`… N more changed lines not shown` **first**, so the truncation is visible
|
||||||
|
without scrolling. The `+N -M` counts still describe the whole edit, never the
|
||||||
|
rendered prefix.
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
|
||||||
|
JUnit XML totals **254 tests, 0 failures, 0 errors, 0 skipped** (new
|
||||||
|
`toolEditDiffSummarisesAnOversizedEditInsteadOfRenderingEveryLine`, which
|
||||||
|
asserts the true `+250 -250` counts, the 200-line render cap and
|
||||||
|
`omitted = 300`; the small-edit test now also pins `omitted = 0`).
|
||||||
|
- The rebuilt debug APK was installed on `emulator-5556` only and driven against
|
||||||
|
`.diff_check/chat_stub_diff.py` (the `.tool_calls_check/chat_stub_tools.py`
|
||||||
|
`/connect` WebSocket double plus a 300-line edit whose intersection with the
|
||||||
|
cap must summarise; stdlib double, test scaffolding, not the app). Captures were
|
||||||
|
validated with `android/scripts/capture_png.sh -s emulator-5556`:
|
||||||
|
`03_diff_small.png` shows the small edit card — `src/layout.kt +2 -2 300ms`,
|
||||||
|
then red `- val gap = 4.dp` / `- val inset = 1.dp` and green
|
||||||
|
`+ val gap = 6.dp` / `+ val inset = 2.dp` in monospace — and
|
||||||
|
`05_diff_summarised.png` shows `src/big.kt +100 -100 150ms` over
|
||||||
|
`… 200 more changed lines not shown` and the interleaved context/`-`/`+` lines.
|
||||||
|
`uiautomator dump` confirms the same nodes; `adb -s emulator-5556 logcat -d`
|
||||||
|
held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,220,501 bytes, sha256
|
||||||
|
`7cfca9c40361d4f1871bc61da20aec8c918637f8e085b8eb534d134b3cb8fe00`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/133/1/pipelines-debug-wip-291cec2.apk`;
|
||||||
|
`curl -I http://10.0.0.75:8080/artifacts/133/1/pipelines-debug-wip-291cec2.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18220501`, and a streamed `GET | shasum -a 256` matched.
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged from the passes above.
|
||||||
|
`:app:lintDebug` still cannot run here (the Gradle JVM's `25.0.4.1` version
|
||||||
|
string is rejected by AGP 8.7.2 lint), unchanged from the slices above.
|
||||||
|
|
||||||
|
## Stopping a running turn (16 Oct 2026)
|
||||||
|
|
||||||
|
The composer already swapped its send control for a red `Icons.stop` while a turn
|
||||||
|
ran and `AppViewModel.stopChat` already sent `chat_interrupt`; the slice was
|
||||||
|
missing the proof the task asks for — a unit test pinning the interrupt frame —
|
||||||
|
so this pass adds that seam and the on-device capture. `android/` only; no new
|
||||||
|
dependency (still just the declared `material-icons-extended`), no Pipelines
|
||||||
|
server/Go/installer/Docker file touched, no run started from the app, and
|
||||||
|
`emulator-5556` only (lane A's `emulator-5554` was never addressed).
|
||||||
|
|
||||||
|
- **One interrupt frame.** `ChatProtocol.interruptRequest(sessionId)` builds the
|
||||||
|
single `chat_interrupt` frame (a `ChatQuery` carrying the session id);
|
||||||
|
`PipelinesRepository.chatInterrupt` sends it, so the wire shape is no longer
|
||||||
|
constructed inline where only production can see it.
|
||||||
|
- **The stopped state is honest.** On a successful interrupt the thread settles
|
||||||
|
(`running = false`, no error) and the composer's send control returns; only a
|
||||||
|
failing call (or a server-pushed error frame) sets the conversation's error, so
|
||||||
|
a stop the server accepted is never shown as a failure.
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
|
||||||
|
SUCCESSFUL`; the JUnit XML totals **255 tests, 0 failures, 0 errors, 0
|
||||||
|
skipped** (new `chatInterruptRequestCarriesTheRunningSession`, which asserts the
|
||||||
|
frame the stop control sends is `chat_interrupt` for the running session and
|
||||||
|
survives the client's JSON round-trip).
|
||||||
|
- The debug APK was installed on `emulator-5556` only and driven against
|
||||||
|
`.stop_check/chat_stub_hold.py` (a stdlib `/connect` WebSocket double that holds
|
||||||
|
the turn open until `chat_interrupt`; test scaffolding, not the app) with
|
||||||
|
`uiautomator dump`/`input tap`; captures validated with
|
||||||
|
`android/scripts/capture_png.sh -s emulator-5556`:
|
||||||
|
`stop_control_running.png` shows the running turn (`Working… · 11s`) with the
|
||||||
|
composer's send control replaced by the red stop control (bottom-right, in thumb
|
||||||
|
reach) and the top-bar stop action; `stop_control_stopped.png` shows the same
|
||||||
|
chat after the stop was pressed — the indicator gone, the send control back, and
|
||||||
|
no error text (the server acknowledged the interrupt). The stub log recorded
|
||||||
|
exactly one `chat_interrupt`. `adb -s emulator-5556 logcat -d` held 0
|
||||||
|
`FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,240,566 bytes, sha256
|
||||||
|
`56abfb2c59a9c09fabbe32d7de4f0164cdc852cece4b7df3655dd0c233256248`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/135/1/pipelines-debug-wip-e2f306b.apk`;
|
||||||
|
`curl -I http://10.0.0.249:8080/artifacts/135/1/pipelines-debug-wip-e2f306b.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18240566`, and a streamed `GET | shasum -a 256` matched.
|
||||||
|
|
||||||
|
### Follow-up: one tested composer action (16 Oct 2026, run 143)
|
||||||
|
|
||||||
|
The stop control was still chosen by an inline `if (thread.running)` in the
|
||||||
|
composer, and the text field's keyboard send action only checked `canSend`, so a
|
||||||
|
prompt could still be sent from the IME while a turn was in flight even though the
|
||||||
|
visible control had become stop. `ChatFormat.composerAction(thread)`
|
||||||
|
(`ComposerAction.Send`/`Stop`) is now the single pure derivation the trailing
|
||||||
|
button and the keyboard action both read, so the two controls can no longer
|
||||||
|
disagree; `ChatFormatTest.composerControlIsStopWhileARunIsInFlightAndSendOtherwise`
|
||||||
|
covers it. `android/` only; no new dependency.
|
||||||
|
|
||||||
|
- Re-verified: `gradle :app:assembleDebug :app:testDebugUnitTest --offline` →
|
||||||
|
`BUILD SUCCESSFUL`, **266 tests, 0 failures** (the new composer-action case).
|
||||||
|
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` (18,249,033 bytes,
|
||||||
|
sha256 `a9ce0cc8829513ee37fa5abaafa765307d5574f7cbd2b9cf0bc32392d0c1461e`) copied
|
||||||
|
to `~/.local/share/pipelines/data/artifacts/143/1/pipelines-debug-wip-609721d.apk`.
|
||||||
|
`curl -I http://10.0.0.249:8080/artifacts/143/1/pipelines-debug-wip-609721d.apk`
|
||||||
|
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18249033`; a streamed `GET | shasum -a 256` matched.
|
||||||
|
- Not driven on a device in this pass: the constraint that the stop control be
|
||||||
|
exercised on an emulator only conflicts with this run's device note that only the
|
||||||
|
operator's Pixel (adb serial `58281FDCG000JF`) is available and no emulator may be
|
||||||
|
run, so the evidence here is the unit tests and the build rather than a fresh
|
||||||
|
screenshot. The earlier `emulator-5556` captures
|
||||||
|
(`.stop_check/stop_control_running.png`, `.stop_check/stop_control_stopped.png`)
|
||||||
|
still show the running/stopped control states.
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged from the passes above.
|
||||||
|
|
||||||
|
## Approvals in the conversation, answered in place (16 Oct 2026)
|
||||||
|
|
||||||
|
The brokered protocol already carried `chat_permission`, but the phone only showed
|
||||||
|
it as a bar above the composer and removed it the moment it was answered. This
|
||||||
|
pass makes a pushed approval a card in the conversation: the reference app's amber
|
||||||
|
risk framing, once/always/reject actions wired to `chat_reply`, an in-place settle
|
||||||
|
on answer, and a resolved state for a request the server reports as already
|
||||||
|
settled. `android/` only; no new dependency (still just the declared
|
||||||
|
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
|
||||||
|
no run started from the app, and `emulator-5556` only (lane A's `emulator-5554`
|
||||||
|
was never addressed).
|
||||||
|
|
||||||
|
- **The card is in the transcript.** `ApprovalCardItem` is the transcript's last
|
||||||
|
item, so the request sits with the conversation rather than floating above the
|
||||||
|
composer. It shows the action (`Approve edit`), the affected resources in
|
||||||
|
monospace, the amber `RISK REVIEW` panel carrying the server's risk summary
|
||||||
|
(falling back to a neutral sentence naming the action when the server sends
|
||||||
|
none), and `Allow once` / `Always allow` / `Reject`. The amber `tertiary` role
|
||||||
|
at 12% fills the review panel and its shield glyph, and at 50% outlines a
|
||||||
|
pending card — the same amber `shield_outlined` framing the reference app uses.
|
||||||
|
Geometry reuses the existing chat tokens; the only new constants are the two
|
||||||
|
alpha strengths.
|
||||||
|
- **Findable without scrolling the whole chat.** The conversation's top bar shows
|
||||||
|
a gold `PanTool` "Waiting for your approval" action while a request is open;
|
||||||
|
tapping it jumps the transcript to the card, and the same glyph marks the chat's
|
||||||
|
chip in the open-chat strip. A newly arrived request is also scrolled into view
|
||||||
|
by the existing bottom-follow, and the running indicator stands down while the
|
||||||
|
turn waits (the clock would otherwise tick on work that is not happening).
|
||||||
|
- **Answered in place.** `ChatStore.answerPermission` records the decision
|
||||||
|
optimistically, so the card settles to `Allowed once` / `Always allowed` /
|
||||||
|
`Rejected` and drops its actions instead of disappearing; a failed `chat_reply`
|
||||||
|
reopens the same request (`permissionReplyFailed`) with the error, so a decision
|
||||||
|
the server never received is never shown as accepted. `ChatProtocol.replyRequest`
|
||||||
|
is the one builder `PipelinesRepository.chatReply` sends, so the card's actions
|
||||||
|
and the wire frame cannot drift.
|
||||||
|
- **Already resolved is honest.** `ChatPermissionFrame` gained optional `resolved`
|
||||||
|
and `decision` fields. A frame for a request the server reports as settled
|
||||||
|
renders as `Rejected`/`Always allowed`/`Already resolved` with no controls, so a
|
||||||
|
stale once/always/reject is never offered for a closed request; a frame for a
|
||||||
|
new request replaces a settled card. Those fields are the additive contract the
|
||||||
|
server sends when it reports an already-settled request (both are omitted by an
|
||||||
|
older peer, which simply leaves every request pending).
|
||||||
|
|
||||||
|
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
|
||||||
|
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||||||
|
|
||||||
|
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
|
||||||
|
JUnit XML totals **267 tests, 0 failures, 0 errors, 0 skipped** (new
|
||||||
|
`ChatApprovalTest`: a pushed frame yields a pending card with the request's
|
||||||
|
action/resources/risk and its three actions, answering once/always/reject settles
|
||||||
|
the card in place, a server-resolved frame offers no actions, a failed reply
|
||||||
|
reopens the request, and the missing-summary fallback; new
|
||||||
|
`ChatProtocolTest.chatPermissionFrameCarriesTheServerResolution`; the reply
|
||||||
|
builder is asserted for `once`, `always` and `reject` through one shared
|
||||||
|
encode/decode round trip, so no decision is asserted more weakly than another).
|
||||||
|
- The rebuilt debug APK was driven on `emulator-5556` against
|
||||||
|
`.approval_check/chat_stub_approval.py` (a stdlib `/connect` WebSocket double
|
||||||
|
that pushes a pending `chat_permission` after a prompt and a server-resolved one
|
||||||
|
for a second session; test scaffolding, not the app). Fresh captures this pass,
|
||||||
|
validated with `android/scripts/capture_png.sh -s emulator-5556` into
|
||||||
|
`~/.local/share/pipelines/data/artifacts/147/3/`:
|
||||||
|
`01_approval_pending.png` (the `Approve edit` card with `src/layout.kt`, the
|
||||||
|
amber `RISK REVIEW` panel and the three actions, the top-bar pan-tool and the
|
||||||
|
chat-chip marker) and `02_approval_answered.png` (the same card settled to
|
||||||
|
`Always allowed`, no actions, the amber risk panel retired). The stub log
|
||||||
|
recorded the `chat_reply` with `decision=always request=req_pending_1`. The
|
||||||
|
already-resolved path was reached too — the `Already resolved` session rendered
|
||||||
|
`Rejected` with the server's note and no controls — but `emulator-5556` shut
|
||||||
|
down before that frame could be captured, and it is not restarted here, so its
|
||||||
|
evidence is the `uiautomator` dump (`uiautomator_server_resolved.xml`) rather
|
||||||
|
than a second screenshot.
|
||||||
|
- **APK publish.** `app-debug.apk` (18,109,180 bytes, sha256
|
||||||
|
`5f58ac6e92a7fbeb2fd023b5604fd7876e9d2546cc7cadf3d871aa7a4b7cce43`) copied to
|
||||||
|
`~/.local/share/pipelines/data/artifacts/147/3/pipelines-debug-wip-305714c.apk`
|
||||||
|
(`305714c` = `git rev-parse --short HEAD`); the running artifacts server serves
|
||||||
|
`curl -I http://10.0.0.75:8080/artifacts/147/3/pipelines-debug-wip-305714c.apk`
|
||||||
|
as `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||||||
|
`Content-Length: 18109180`, and a streamed `GET | shasum -a 256` matched.
|
||||||
|
|
||||||
|
Not verified in this pass: the live brokered server (separate lane), streaming
|
||||||
|
against real OpenCode, and attachments — unchanged from the passes above. The
|
||||||
|
`resolved`/`decision` frame fields are the additive contract the server must send
|
||||||
|
when it reports an already-settled request; the live server does not emit them
|
||||||
|
yet, so only the unit test and the stub exercise that path. `:app:lintDebug` still
|
||||||
|
cannot run here (the Gradle JVM's version string is rejected by AGP 8.7.2 lint),
|
||||||
|
unchanged from the slices above. `emulator-5556` — this lane's standing device,
|
||||||
|
already running when the pass began and never started or restarted here — shut
|
||||||
|
down after the second capture, so the resolved frame was confirmed from the
|
||||||
|
accessibility tree rather than a screenshot. The run's device note (all device work
|
||||||
|
through the attached Pixel, no emulator) conflicts with the task constraint
|
||||||
|
(emulator only, never install on the person's device); this pass resolved it by
|
||||||
|
using the already-running emulator and never installing on the Pixel.
|
||||||
|
|||||||
@@ -32,7 +32,7 @@
|
|||||||
android:exported="true"
|
android:exported="true"
|
||||||
android:label="@string/app_name"
|
android:label="@string/app_name"
|
||||||
android:theme="@style/Theme.Pipelines"
|
android:theme="@style/Theme.Pipelines"
|
||||||
android:windowSoftInputMode="adjustNothing">
|
android:windowSoftInputMode="adjustResize">
|
||||||
<intent-filter>
|
<intent-filter>
|
||||||
<action android:name="android.intent.action.MAIN" />
|
<action android:name="android.intent.action.MAIN" />
|
||||||
<category android:name="android.intent.category.LAUNCHER" />
|
<category android:name="android.intent.category.LAUNCHER" />
|
||||||
|
|||||||
@@ -2,8 +2,15 @@ package net.awan.pipelines.data
|
|||||||
|
|
||||||
import java.util.UUID
|
import java.util.UUID
|
||||||
import java.util.concurrent.ConcurrentHashMap
|
import java.util.concurrent.ConcurrentHashMap
|
||||||
|
import kotlinx.coroutines.flow.SharedFlow
|
||||||
import kotlinx.serialization.json.JsonPrimitive
|
import kotlinx.serialization.json.JsonPrimitive
|
||||||
import kotlinx.serialization.json.JsonElement
|
import kotlinx.serialization.json.JsonElement
|
||||||
|
import net.awan.pipelines.data.protocol.ChatCreateRequest
|
||||||
|
import net.awan.pipelines.data.protocol.ChatMessage
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPromptRequest
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatQuery
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
import net.awan.pipelines.data.protocol.Message
|
import net.awan.pipelines.data.protocol.Message
|
||||||
import net.awan.pipelines.data.protocol.PipelineDetail
|
import net.awan.pipelines.data.protocol.PipelineDetail
|
||||||
import net.awan.pipelines.data.protocol.PipelineSummary
|
import net.awan.pipelines.data.protocol.PipelineSummary
|
||||||
@@ -32,6 +39,9 @@ class PipelinesRepository(
|
|||||||
) {
|
) {
|
||||||
val connectionState = client.state
|
val connectionState = client.state
|
||||||
|
|
||||||
|
/** Server-pushed chat frames (chat_event / chat_permission), with no request id. */
|
||||||
|
val events: SharedFlow<Message> = client.events
|
||||||
|
|
||||||
/** Opens the single shared connection to a validated server URL. */
|
/** Opens the single shared connection to a validated server URL. */
|
||||||
fun connect(validated: ServerUrl.Validated) = client.connect(validated)
|
fun connect(validated: ServerUrl.Validated) = client.connect(validated)
|
||||||
|
|
||||||
@@ -129,6 +139,62 @@ class PipelinesRepository(
|
|||||||
Message(type = Protocol.RETRY_RUN, runId = id, requestKey = requestKey),
|
Message(type = Protocol.RETRY_RUN, runId = id, requestKey = requestKey),
|
||||||
).runDetail ?: throw ProtocolException("The server returned no run detail.")
|
).runDetail ?: throw ProtocolException("The server returned no run detail.")
|
||||||
|
|
||||||
|
// ---- Brokered OpenCode chat (route B): the phone never speaks OpenCode
|
||||||
|
// directly and never holds its credentials. ----
|
||||||
|
|
||||||
|
/** Lists the sessions this server owns, with the `busy` flag the phone renders read-only. */
|
||||||
|
suspend fun chatSessions(): List<ChatSession> =
|
||||||
|
client.call(Message(type = Protocol.CHAT_SESSIONS)).chatSessions ?: emptyList()
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Creates a session and returns it. The server currently answers this type
|
||||||
|
* with an explicit error when it does not broker creation; the caller
|
||||||
|
* surfaces that message rather than guessing at a session id.
|
||||||
|
*/
|
||||||
|
suspend fun chatCreate(title: String, directory: String): ChatSession {
|
||||||
|
val response = client.call(
|
||||||
|
Message(
|
||||||
|
type = Protocol.CHAT_CREATE,
|
||||||
|
chatCreate = ChatCreateRequest(title = title, directory = directory),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
return response.chatSession
|
||||||
|
?: throw ProtocolException("The server did not return the new chat session.")
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Loads a session's stored turns; the server prefers its retained live state. */
|
||||||
|
suspend fun chatMessages(sessionId: String, limit: Int = 0): List<ChatMessage> {
|
||||||
|
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
|
||||||
|
return client.call(
|
||||||
|
Message(type = Protocol.CHAT_MESSAGES, chatQuery = ChatQuery(sessionId = sessionId, limit = limit)),
|
||||||
|
).chatMessages ?: emptyList()
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Sends one prompt; the server echoes an ack and then pushes chat_event frames. */
|
||||||
|
suspend fun chatPrompt(sessionId: String, text: String) {
|
||||||
|
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
|
||||||
|
val trimmed = text.trim()
|
||||||
|
if (trimmed.isEmpty()) throw ProtocolException("Enter a message before sending.")
|
||||||
|
client.call(
|
||||||
|
Message(
|
||||||
|
type = Protocol.CHAT_PROMPT,
|
||||||
|
chatPrompt = ChatPromptRequest(sessionId = sessionId, text = trimmed),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
suspend fun chatInterrupt(sessionId: String) {
|
||||||
|
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
|
||||||
|
client.call(ChatProtocol.interruptRequest(sessionId))
|
||||||
|
}
|
||||||
|
|
||||||
|
suspend fun chatReply(sessionId: String, requestId: String, decision: String, message: String = "") {
|
||||||
|
if (sessionId.isBlank() || requestId.isBlank()) {
|
||||||
|
throw ProtocolException("A pending permission request is required.")
|
||||||
|
}
|
||||||
|
client.call(ChatProtocol.replyRequest(sessionId, requestId, decision, message))
|
||||||
|
}
|
||||||
|
|
||||||
private fun requireConfigured() {
|
private fun requireConfigured() {
|
||||||
if (settings.serverUrl.value.isBlank()) {
|
if (settings.serverUrl.value.isBlank()) {
|
||||||
throw NotConnectedException("Set the Pipelines server URL in Settings first.")
|
throw NotConnectedException("Set the Pipelines server URL in Settings first.")
|
||||||
|
|||||||
@@ -0,0 +1,233 @@
|
|||||||
|
package net.awan.pipelines.data.protocol
|
||||||
|
|
||||||
|
import kotlinx.serialization.SerialName
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
import kotlinx.serialization.json.JsonElement
|
||||||
|
import kotlinx.serialization.json.JsonObject
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Brokered OpenCode chat wire types (route B in the research report): the phone
|
||||||
|
* talks only to `/connect` and the server holds the OpenCode credentials,
|
||||||
|
* translating each type below. The field names and JSON tags mirror
|
||||||
|
* `internal/protocol/chat.go` exactly so the two cannot drift.
|
||||||
|
*
|
||||||
|
* Every list/field is optional with a default, so an older peer or a partial
|
||||||
|
* envelope never crashes the client.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class ChatSession(
|
||||||
|
val id: String = "",
|
||||||
|
val title: String = "",
|
||||||
|
val agent: String = "",
|
||||||
|
val model: String = "",
|
||||||
|
val directory: String = "",
|
||||||
|
@SerialName("parent_id") val parentId: String = "",
|
||||||
|
@SerialName("created_at") val createdAt: Long = 0,
|
||||||
|
@SerialName("updated_at") val updatedAt: Long = 0,
|
||||||
|
// Another client holds the session, or the server itself owns it as an active
|
||||||
|
// run: the phone shows it read-only instead of letting two clients write the
|
||||||
|
// same conversation.
|
||||||
|
val busy: Boolean = false,
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatCreateRequest(
|
||||||
|
val title: String = "",
|
||||||
|
val directory: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
/** The session-scoped request body for chat_messages and chat_interrupt. */
|
||||||
|
@Serializable
|
||||||
|
data class ChatQuery(
|
||||||
|
@SerialName("session_id") val sessionId: String = "",
|
||||||
|
val limit: Int = 0,
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatPromptRequest(
|
||||||
|
@SerialName("session_id") val sessionId: String = "",
|
||||||
|
val text: String = "",
|
||||||
|
val model: String = "",
|
||||||
|
val agent: String = "",
|
||||||
|
val files: List<String> = emptyList(),
|
||||||
|
)
|
||||||
|
|
||||||
|
/** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */
|
||||||
|
@Serializable
|
||||||
|
data class ChatMessage(
|
||||||
|
val id: String = "",
|
||||||
|
@SerialName("session_id") val sessionId: String = "",
|
||||||
|
val role: String = "",
|
||||||
|
val model: String = "",
|
||||||
|
val agent: String = "",
|
||||||
|
@SerialName("created_at") val createdAt: Long = 0,
|
||||||
|
val parts: List<ChatPart> = emptyList(),
|
||||||
|
)
|
||||||
|
|
||||||
|
/** One element of a [ChatMessage]; [type] selects which fields are meaningful. */
|
||||||
|
@Serializable
|
||||||
|
data class ChatPart(
|
||||||
|
val type: String = "",
|
||||||
|
val id: String = "",
|
||||||
|
val text: String = "",
|
||||||
|
val name: String = "",
|
||||||
|
val executed: Boolean = false,
|
||||||
|
val state: ChatToolState? = null,
|
||||||
|
val time: ChatTime? = null,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** The lifecycle of a tool call; [input] is a partial-JSON string while streaming, an object afterwards. */
|
||||||
|
@Serializable
|
||||||
|
data class ChatToolState(
|
||||||
|
val status: String = "",
|
||||||
|
val input: JsonElement? = null,
|
||||||
|
val content: List<ChatToolContent> = emptyList(),
|
||||||
|
val metadata: JsonObject? = null,
|
||||||
|
val error: ChatError? = null,
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatToolContent(
|
||||||
|
val type: String = "",
|
||||||
|
val text: String = "",
|
||||||
|
val uri: String = "",
|
||||||
|
val mime: String = "",
|
||||||
|
val name: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatError(
|
||||||
|
val type: String = "",
|
||||||
|
val message: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
/** Epoch-millisecond timing envelope of a tool call. */
|
||||||
|
@Serializable
|
||||||
|
data class ChatTime(
|
||||||
|
val created: Long = 0,
|
||||||
|
val ran: Long = 0,
|
||||||
|
val completed: Long = 0,
|
||||||
|
)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A server-pushed chat_event frame. [kind] selects the payload: text/reasoning
|
||||||
|
* carry an incremental [delta] for the target [part], tool carries a full [part],
|
||||||
|
* step marks turn progress and usage reports the turn totals.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class ChatEventFrame(
|
||||||
|
@SerialName("session_id") val sessionId: String = "",
|
||||||
|
@SerialName("message_id") val messageId: String = "",
|
||||||
|
val kind: String = "",
|
||||||
|
val delta: String = "",
|
||||||
|
val part: ChatPart? = null,
|
||||||
|
val step: ChatStep? = null,
|
||||||
|
val usage: ChatUsage? = null,
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatStep(
|
||||||
|
val status: String = "",
|
||||||
|
val index: Int = 0,
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatUsage(
|
||||||
|
@SerialName("input_tokens") val inputTokens: Int = 0,
|
||||||
|
@SerialName("output_tokens") val outputTokens: Int = 0,
|
||||||
|
val cost: Double = 0.0,
|
||||||
|
)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* One pending OpenCode approval request the phone answers with chat_reply.
|
||||||
|
*
|
||||||
|
* [resolved] and [decision] carry the server's outcome when it reports a request
|
||||||
|
* that is no longer open (another client answered it, or it expired): the phone
|
||||||
|
* then shows the verdict instead of live controls. They are additive and
|
||||||
|
* optional, so an older peer simply never sets them and every request stays
|
||||||
|
* pending.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class ChatPermissionFrame(
|
||||||
|
@SerialName("session_id") val sessionId: String = "",
|
||||||
|
@SerialName("request_id") val requestId: String = "",
|
||||||
|
val action: String = "",
|
||||||
|
val resources: List<String> = emptyList(),
|
||||||
|
val save: List<String> = emptyList(),
|
||||||
|
val metadata: JsonObject? = null,
|
||||||
|
val source: ChatPermissionSource? = null,
|
||||||
|
val message: String = "",
|
||||||
|
val resolved: Boolean = false,
|
||||||
|
val decision: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatPermissionSource(
|
||||||
|
val type: String = "",
|
||||||
|
@SerialName("message_id") val messageId: String = "",
|
||||||
|
val id: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class ChatReplyRequest(
|
||||||
|
@SerialName("session_id") val sessionId: String = "",
|
||||||
|
@SerialName("request_id") val requestId: String = "",
|
||||||
|
val decision: String = "",
|
||||||
|
val message: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
/** Chat part/kind/state/reply constants, mirroring `internal/protocol/chat.go`. */
|
||||||
|
object ChatProtocol {
|
||||||
|
const val PART_TEXT = "text"
|
||||||
|
const val PART_REASONING = "reasoning"
|
||||||
|
const val PART_TOOL = "tool"
|
||||||
|
|
||||||
|
const val EVENT_STEP = "step"
|
||||||
|
const val EVENT_USAGE = "usage"
|
||||||
|
|
||||||
|
const val STEP_STARTED = "started"
|
||||||
|
const val STEP_ENDED = "ended"
|
||||||
|
|
||||||
|
const val TOOL_STREAMING = "streaming"
|
||||||
|
const val TOOL_RUNNING = "running"
|
||||||
|
const val TOOL_COMPLETED = "completed"
|
||||||
|
const val TOOL_ERROR = "error"
|
||||||
|
|
||||||
|
const val ROLE_USER = "user"
|
||||||
|
const val ROLE_ASSISTANT = "assistant"
|
||||||
|
|
||||||
|
const val DECISION_ONCE = "once"
|
||||||
|
const val DECISION_ALWAYS = "always"
|
||||||
|
const val DECISION_REJECT = "reject"
|
||||||
|
|
||||||
|
/** A tool call still in flight (no result or error yet). */
|
||||||
|
fun toolRunning(state: ChatToolState?): Boolean = when (state?.status) {
|
||||||
|
TOOL_STREAMING, TOOL_RUNNING -> true
|
||||||
|
else -> false
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The `chat_interrupt` frame the composer's stop control sends: the server
|
||||||
|
* aborts the in-flight turn for [sessionId]. Built here (not inline in the
|
||||||
|
* repository) so production and its unit test share the one wire shape.
|
||||||
|
*/
|
||||||
|
fun interruptRequest(sessionId: String): Message =
|
||||||
|
Message(type = Protocol.CHAT_INTERRUPT, chatQuery = ChatQuery(sessionId = sessionId))
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The `chat_reply` frame that answers one permission request: [decision] is
|
||||||
|
* one of [DECISION_ONCE]/[DECISION_ALWAYS]/[DECISION_REJECT]. Built here (not
|
||||||
|
* inline in the repository) so the approval card's actions and their unit
|
||||||
|
* test share the one wire shape.
|
||||||
|
*/
|
||||||
|
fun replyRequest(sessionId: String, requestId: String, decision: String, message: String = ""): Message =
|
||||||
|
Message(
|
||||||
|
type = Protocol.CHAT_REPLY,
|
||||||
|
chatReply = ChatReplyRequest(
|
||||||
|
sessionId = sessionId,
|
||||||
|
requestId = requestId,
|
||||||
|
decision = decision,
|
||||||
|
message = message,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
}
|
||||||
@@ -53,6 +53,16 @@ object Protocol {
|
|||||||
const val SEARCH_KIND_STEP = "step"
|
const val SEARCH_KIND_STEP = "step"
|
||||||
const val SEARCH_KIND_FIELD = "field"
|
const val SEARCH_KIND_FIELD = "field"
|
||||||
const val SEARCH_KIND_ARTIFACT = "artifact"
|
const val SEARCH_KIND_ARTIFACT = "artifact"
|
||||||
|
// chat.go (brokered OpenCode chat)
|
||||||
|
const val CHAT_SESSIONS = "chat_sessions"
|
||||||
|
const val CHAT_CREATE = "chat_create"
|
||||||
|
const val CHAT_PROMPT = "chat_prompt"
|
||||||
|
const val CHAT_MESSAGES = "chat_messages"
|
||||||
|
const val CHAT_INTERRUPT = "chat_interrupt"
|
||||||
|
const val CHAT_REPLY = "chat_reply"
|
||||||
|
// Server-pushed frames with no matching request.
|
||||||
|
const val CHAT_EVENT = "chat_event"
|
||||||
|
const val CHAT_PERMISSION = "chat_permission"
|
||||||
|
|
||||||
// terminals.go
|
// terminals.go
|
||||||
const val SUCCESS_END = "#success"
|
const val SUCCESS_END = "#success"
|
||||||
@@ -562,4 +572,15 @@ data class Message(
|
|||||||
@SerialName("write_paths") val writePaths: List<String>? = null,
|
@SerialName("write_paths") val writePaths: List<String>? = null,
|
||||||
@SerialName("request_key") val requestKey: String? = null,
|
@SerialName("request_key") val requestKey: String? = null,
|
||||||
val workspace: String? = null,
|
val workspace: String? = null,
|
||||||
|
// Brokered chat traffic (see Chat.kt). Optional so an older server never
|
||||||
|
// breaks the existing envelope.
|
||||||
|
@SerialName("chat_sessions") val chatSessions: List<ChatSession>? = null,
|
||||||
|
@SerialName("chat_session") val chatSession: ChatSession? = null,
|
||||||
|
@SerialName("chat_create") val chatCreate: ChatCreateRequest? = null,
|
||||||
|
@SerialName("chat_query") val chatQuery: ChatQuery? = null,
|
||||||
|
@SerialName("chat_prompt") val chatPrompt: ChatPromptRequest? = null,
|
||||||
|
@SerialName("chat_messages") val chatMessages: List<ChatMessage>? = null,
|
||||||
|
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
|
||||||
|
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
|
||||||
|
@SerialName("chat_reply") val chatReply: ChatReplyRequest? = null,
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -10,8 +10,11 @@ import kotlinx.coroutines.CoroutineScope
|
|||||||
import kotlinx.coroutines.Dispatchers
|
import kotlinx.coroutines.Dispatchers
|
||||||
import kotlinx.coroutines.Job
|
import kotlinx.coroutines.Job
|
||||||
import kotlinx.coroutines.delay
|
import kotlinx.coroutines.delay
|
||||||
|
import kotlinx.coroutines.flow.MutableSharedFlow
|
||||||
import kotlinx.coroutines.flow.MutableStateFlow
|
import kotlinx.coroutines.flow.MutableStateFlow
|
||||||
|
import kotlinx.coroutines.flow.SharedFlow
|
||||||
import kotlinx.coroutines.flow.StateFlow
|
import kotlinx.coroutines.flow.StateFlow
|
||||||
|
import kotlinx.coroutines.flow.asSharedFlow
|
||||||
import kotlinx.coroutines.flow.asStateFlow
|
import kotlinx.coroutines.flow.asStateFlow
|
||||||
import kotlinx.coroutines.launch
|
import kotlinx.coroutines.launch
|
||||||
import kotlinx.coroutines.sync.Mutex
|
import kotlinx.coroutines.sync.Mutex
|
||||||
@@ -53,6 +56,15 @@ class PipelinesClient(
|
|||||||
private val _state = MutableStateFlow<ConnectionState>(ConnectionState.Idle)
|
private val _state = MutableStateFlow<ConnectionState>(ConnectionState.Idle)
|
||||||
val state: StateFlow<ConnectionState> = _state.asStateFlow()
|
val state: StateFlow<ConnectionState> = _state.asStateFlow()
|
||||||
|
|
||||||
|
// Unsolicited server frames (server-pushed chat_event / chat_permission /
|
||||||
|
// stream errors). Buffered and dropped-oldest so a slow collector can never
|
||||||
|
// block the socket read loop; chats re-sync from history after a gap anyway.
|
||||||
|
private val _events = MutableSharedFlow<Message>(
|
||||||
|
extraBufferCapacity = 256,
|
||||||
|
onBufferOverflow = kotlinx.coroutines.channels.BufferOverflow.DROP_OLDEST,
|
||||||
|
)
|
||||||
|
val events: SharedFlow<Message> = _events.asSharedFlow()
|
||||||
|
|
||||||
private val sendLock = Mutex()
|
private val sendLock = Mutex()
|
||||||
private val pending = ConcurrentHashMap<String, CompletableDeferred<Message>>()
|
private val pending = ConcurrentHashMap<String, CompletableDeferred<Message>>()
|
||||||
private val sequence = AtomicLong(0)
|
private val sequence = AtomicLong(0)
|
||||||
@@ -190,9 +202,12 @@ class PipelinesClient(
|
|||||||
val deferred = if (id != null) pending.remove(id) else null
|
val deferred = if (id != null) pending.remove(id) else null
|
||||||
if (deferred != null) {
|
if (deferred != null) {
|
||||||
deferred.complete(message)
|
deferred.complete(message)
|
||||||
|
} else {
|
||||||
|
// Unsolicited envelopes (the connection's initial pipeline_list,
|
||||||
|
// server-pushed chat frames, stream errors) carry no matching id:
|
||||||
|
// hand them to the event stream instead of dropping them.
|
||||||
|
_events.tryEmit(message)
|
||||||
}
|
}
|
||||||
// Unsolicited envelopes (for example the connection's initial
|
|
||||||
// pipeline_list) have no matching id and are intentionally dropped.
|
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
|
override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
|
||||||
|
|||||||
@@ -21,6 +21,7 @@ import net.awan.pipelines.data.PipelinesRepository
|
|||||||
import net.awan.pipelines.data.RunHistory
|
import net.awan.pipelines.data.RunHistory
|
||||||
import net.awan.pipelines.data.SettingsRepository
|
import net.awan.pipelines.data.SettingsRepository
|
||||||
import net.awan.pipelines.data.protocol.BuildInfo
|
import net.awan.pipelines.data.protocol.BuildInfo
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
import net.awan.pipelines.data.protocol.PipelineDetail
|
import net.awan.pipelines.data.protocol.PipelineDetail
|
||||||
import net.awan.pipelines.data.protocol.PipelineSummary
|
import net.awan.pipelines.data.protocol.PipelineSummary
|
||||||
import net.awan.pipelines.data.protocol.Protocol
|
import net.awan.pipelines.data.protocol.Protocol
|
||||||
@@ -29,6 +30,8 @@ import net.awan.pipelines.data.protocol.SearchResponse
|
|||||||
import net.awan.pipelines.data.protocol.SessionEvidence
|
import net.awan.pipelines.data.protocol.SessionEvidence
|
||||||
import net.awan.pipelines.data.transport.ConnectionState
|
import net.awan.pipelines.data.transport.ConnectionState
|
||||||
import net.awan.pipelines.data.transport.ServerUrl
|
import net.awan.pipelines.data.transport.ServerUrl
|
||||||
|
import net.awan.pipelines.ui.chat.ChatState
|
||||||
|
import net.awan.pipelines.ui.chat.ChatStore
|
||||||
|
|
||||||
/** Generic loading/empty/error/data state used by every screen. */
|
/** Generic loading/empty/error/data state used by every screen. */
|
||||||
data class LoadState<T>(
|
data class LoadState<T>(
|
||||||
@@ -110,6 +113,10 @@ class AppViewModel(
|
|||||||
private val startKeys = ConcurrentHashMap<Long, String>()
|
private val startKeys = ConcurrentHashMap<Long, String>()
|
||||||
private val retryKeys = ConcurrentHashMap<Long, String>()
|
private val retryKeys = ConcurrentHashMap<Long, String>()
|
||||||
|
|
||||||
|
/** The multi-chat screen state (sessions, open conversations, drafts, scroll). */
|
||||||
|
private val chatStore = ChatStore()
|
||||||
|
val chat: StateFlow<ChatState> = chatStore.state
|
||||||
|
|
||||||
init {
|
init {
|
||||||
// Connect on launch when a server URL is already saved, reusing the shared
|
// Connect on launch when a server URL is already saved, reusing the shared
|
||||||
// client and its bounded backoff (no new client, DI or polling). init runs
|
// client and its bounded backoff (no new client, DI or polling). init runs
|
||||||
@@ -120,6 +127,50 @@ class AppViewModel(
|
|||||||
) {
|
) {
|
||||||
reconnect()
|
reconnect()
|
||||||
}
|
}
|
||||||
|
observeChatEvents()
|
||||||
|
observeConnection()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Routes server-pushed chat frames into the per-chat state, wherever the
|
||||||
|
* frame's session sits in the open order. Frames for a chat that is not open
|
||||||
|
* create a placeholder in [ChatStore.event] so a running background chat
|
||||||
|
* keeps its stream; the operator sees it re-synced from history on return.
|
||||||
|
*/
|
||||||
|
private fun observeChatEvents() {
|
||||||
|
viewModelScope.launch {
|
||||||
|
repository.events.collect { message ->
|
||||||
|
message.chatEvent?.let { chatStore.event(it) }
|
||||||
|
// Never silently drop an approval request: it is held per chat and
|
||||||
|
// answered with chat_reply from the conversation's approval card.
|
||||||
|
message.chatPermission?.let { chatStore.permission(it) }
|
||||||
|
// An unsolicited server error has no request id to match, so it is
|
||||||
|
// the chat stream failing mid-turn: settle the running chat instead
|
||||||
|
// of leaving its indicator spinning forever.
|
||||||
|
if (message.id == null && message.type == Protocol.ERROR) {
|
||||||
|
chatStore.streamError(message.error?.takeIf { it.isNotBlank() } ?: "The chat stream failed.")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Re-syncs every open chat when the socket (re)connects: the frames sent
|
||||||
|
* during the gap are gone, so the conversation is re-fetched from history
|
||||||
|
* rather than trusted. A running chat is marked settled first and a still-live
|
||||||
|
* stream re-asserts it on its next frame, so a stale `Working…` never sticks.
|
||||||
|
*/
|
||||||
|
private fun observeConnection() {
|
||||||
|
viewModelScope.launch {
|
||||||
|
var connected = false
|
||||||
|
connectionState.collect { state ->
|
||||||
|
val isConnected = state is ConnectionState.Connected
|
||||||
|
if (isConnected && !connected) {
|
||||||
|
chatStore.streamResumed().forEach { loadChatHistory(it) }
|
||||||
|
}
|
||||||
|
connected = isConnected
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fun updateServerUrlDraft(value: String) {
|
fun updateServerUrlDraft(value: String) {
|
||||||
@@ -357,6 +408,125 @@ class AppViewModel(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// ---- Brokered chat -------------------------------------------------------
|
||||||
|
|
||||||
|
/** Refreshes the server's session list; never clears open conversations. */
|
||||||
|
fun refreshChatSessions() {
|
||||||
|
viewModelScope.launch {
|
||||||
|
chatStore.sessionsLoading()
|
||||||
|
try {
|
||||||
|
chatStore.sessionsLoaded(repository.chatSessions())
|
||||||
|
} catch (t: Throwable) {
|
||||||
|
if (t is CancellationException) throw t
|
||||||
|
chatStore.sessionsFailed(ErrorMessages.describe(t))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Opens [session] and makes it active. A brand-new chat always loads its
|
||||||
|
* history; a running one re-syncs from the server so a stale copy is never
|
||||||
|
* shown on return.
|
||||||
|
*/
|
||||||
|
fun openChatSession(session: ChatSession) {
|
||||||
|
val needsHistory = chatStore.open(session)
|
||||||
|
if (needsHistory) loadChatHistory(session.id)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Switches to an already-open chat, re-syncing it when it is running. */
|
||||||
|
fun activateChat(sessionId: String) {
|
||||||
|
if (chatStore.activate(sessionId)) loadChatHistory(sessionId)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Shows the session list again while keeping every open conversation. */
|
||||||
|
fun showChatList() = chatStore.showList()
|
||||||
|
|
||||||
|
fun closeChat(sessionId: String) = chatStore.close(sessionId)
|
||||||
|
|
||||||
|
fun updateChatDraft(sessionId: String, text: String) = chatStore.draft(sessionId, text)
|
||||||
|
|
||||||
|
fun saveChatScroll(sessionId: String, index: Int, offset: Int) = chatStore.scroll(sessionId, index, offset)
|
||||||
|
|
||||||
|
/** Creates a session on the server and opens it. Reports the server's own error on failure. */
|
||||||
|
fun newChat() {
|
||||||
|
viewModelScope.launch {
|
||||||
|
try {
|
||||||
|
val created = repository.chatCreate(title = "New chat", directory = settings.workspace.value)
|
||||||
|
chatStore.sessionsLoaded(chatStore.value.sessions + created)
|
||||||
|
chatStore.open(created)
|
||||||
|
chatStore.history(created.id, emptyList())
|
||||||
|
} catch (t: Throwable) {
|
||||||
|
if (t is CancellationException) throw t
|
||||||
|
chatStore.sessionsFailed(ErrorMessages.describe(t))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun loadChatHistory(sessionId: String) {
|
||||||
|
viewModelScope.launch {
|
||||||
|
chatStore.historyLoading(sessionId)
|
||||||
|
try {
|
||||||
|
chatStore.history(sessionId, repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT))
|
||||||
|
} catch (t: Throwable) {
|
||||||
|
if (t is CancellationException) throw t
|
||||||
|
chatStore.failed(sessionId, ErrorMessages.describe(t))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Sends the active chat's draft. Read-only chats are never written to. */
|
||||||
|
fun sendChatPrompt(sessionId: String) {
|
||||||
|
val thread = chatStore.value.thread(sessionId) ?: return
|
||||||
|
if (thread.readOnly) return
|
||||||
|
val text = thread.draft.trim()
|
||||||
|
if (text.isEmpty()) return
|
||||||
|
chatStore.appendLocalUserMessage(sessionId, text)
|
||||||
|
chatStore.clearDraft(sessionId)
|
||||||
|
chatStore.running(sessionId, true)
|
||||||
|
viewModelScope.launch {
|
||||||
|
try {
|
||||||
|
repository.chatPrompt(sessionId, text)
|
||||||
|
} catch (t: Throwable) {
|
||||||
|
if (t is CancellationException) throw t
|
||||||
|
chatStore.failed(sessionId, ErrorMessages.describe(t))
|
||||||
|
chatStore.running(sessionId, false)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Answers a pending approval. The card settles in place optimistically so a
|
||||||
|
* laggy round-trip over a tunnel never shows the old buttons again; a failed
|
||||||
|
* reply reopens the same request and reports why, so the operator can retry
|
||||||
|
* instead of trusting a decision the server never received.
|
||||||
|
*/
|
||||||
|
fun replyChatPermission(sessionId: String, requestId: String, decision: String) {
|
||||||
|
if (sessionId.isBlank() || requestId.isBlank()) return
|
||||||
|
chatStore.answerPermission(sessionId, requestId, decision)
|
||||||
|
viewModelScope.launch {
|
||||||
|
try {
|
||||||
|
repository.chatReply(sessionId, requestId, decision)
|
||||||
|
} catch (t: Throwable) {
|
||||||
|
if (t is CancellationException) throw t
|
||||||
|
chatStore.permissionReplyFailed(sessionId, requestId)
|
||||||
|
chatStore.failed(sessionId, ErrorMessages.describe(t))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun stopChat(sessionId: String) {
|
||||||
|
viewModelScope.launch {
|
||||||
|
try {
|
||||||
|
repository.chatInterrupt(sessionId)
|
||||||
|
} catch (t: Throwable) {
|
||||||
|
if (t is CancellationException) throw t
|
||||||
|
chatStore.failed(sessionId, ErrorMessages.describe(t))
|
||||||
|
} finally {
|
||||||
|
chatStore.running(sessionId, false)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
private fun <T> load(target: MutableStateFlow<LoadState<T>>, block: suspend () -> T) {
|
private fun <T> load(target: MutableStateFlow<LoadState<T>>, block: suspend () -> T) {
|
||||||
viewModelScope.launch {
|
viewModelScope.launch {
|
||||||
target.value = target.value.copy(loading = true, error = null)
|
target.value = target.value.copy(loading = true, error = null)
|
||||||
@@ -374,6 +544,8 @@ class AppViewModel(
|
|||||||
|
|
||||||
/** How long the field waits after the last keystroke before issuing one request. */
|
/** How long the field waits after the last keystroke before issuing one request. */
|
||||||
const val SEARCH_DEBOUNCE_MILLIS = 250L
|
const val SEARCH_DEBOUNCE_MILLIS = 250L
|
||||||
|
/** Bounds one history fetch; the server applies its own cap too. */
|
||||||
|
private const val CHAT_HISTORY_LIMIT = 200
|
||||||
|
|
||||||
fun factory(app: PipelinesApplication) = viewModelFactory {
|
fun factory(app: PipelinesApplication) = viewModelFactory {
|
||||||
initializer { AppViewModel(app.repository, app.settings) }
|
initializer { AppViewModel(app.repository, app.settings) }
|
||||||
|
|||||||
@@ -37,6 +37,7 @@ import androidx.compose.foundation.text.BasicTextField
|
|||||||
import androidx.compose.foundation.text.KeyboardActions
|
import androidx.compose.foundation.text.KeyboardActions
|
||||||
import androidx.compose.foundation.text.KeyboardOptions
|
import androidx.compose.foundation.text.KeyboardOptions
|
||||||
import androidx.compose.material.icons.Icons
|
import androidx.compose.material.icons.Icons
|
||||||
|
import androidx.compose.material.icons.automirrored.filled.Chat
|
||||||
import androidx.compose.material.icons.filled.AccountTree
|
import androidx.compose.material.icons.filled.AccountTree
|
||||||
import androidx.compose.material.icons.filled.Close
|
import androidx.compose.material.icons.filled.Close
|
||||||
import androidx.compose.material.icons.filled.History
|
import androidx.compose.material.icons.filled.History
|
||||||
@@ -96,12 +97,14 @@ import net.awan.pipelines.ui.theme.DESTINATION_PILL_RESERVE
|
|||||||
import net.awan.pipelines.ui.theme.SPACING_M
|
import net.awan.pipelines.ui.theme.SPACING_M
|
||||||
import net.awan.pipelines.ui.theme.SPACING_S
|
import net.awan.pipelines.ui.theme.SPACING_S
|
||||||
import net.awan.pipelines.ui.theme.SPACING_XS
|
import net.awan.pipelines.ui.theme.SPACING_XS
|
||||||
|
import net.awan.pipelines.ui.chat.ChatScreen
|
||||||
|
|
||||||
private data class TopDestination(val route: String, val label: String, val icon: ImageVector)
|
private data class TopDestination(val route: String, val label: String, val icon: ImageVector)
|
||||||
|
|
||||||
private val destinations = listOf(
|
private val destinations = listOf(
|
||||||
TopDestination("pipelines", "Pipelines", Icons.Default.AccountTree),
|
TopDestination("pipelines", "Pipelines", Icons.Default.AccountTree),
|
||||||
TopDestination("runs", "Runs", Icons.Default.History),
|
TopDestination("runs", "Runs", Icons.Default.History),
|
||||||
|
TopDestination("chat", "Chat", Icons.AutoMirrored.Filled.Chat),
|
||||||
TopDestination("settings", "Settings", Icons.Default.Settings),
|
TopDestination("settings", "Settings", Icons.Default.Settings),
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -263,6 +266,9 @@ fun PipelinesApp(vm: AppViewModel) {
|
|||||||
listState = runListState,
|
listState = runListState,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
composable("chat") {
|
||||||
|
ChatScreen(vm = vm, wide = wide)
|
||||||
|
}
|
||||||
composable("settings") {
|
composable("settings") {
|
||||||
SettingsScreen(vm)
|
SettingsScreen(vm)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,312 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import kotlinx.serialization.json.JsonArray
|
||||||
|
import kotlinx.serialization.json.JsonElement
|
||||||
|
import kotlinx.serialization.json.JsonObject
|
||||||
|
import kotlinx.serialization.json.JsonPrimitive
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPart
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPermissionFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
|
import net.awan.pipelines.data.protocol.ChatToolState
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Pure chat formatting helpers shared by the session list and the conversation,
|
||||||
|
* so the same value is never spelled differently in two places. Kept free of
|
||||||
|
* Compose and of the transport so they are unit-testable.
|
||||||
|
*/
|
||||||
|
private val PRETTY_JSON = Json { prettyPrint = true; isLenient = true }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The INPUT section of a tool call: pretty-printed JSON once the arguments are
|
||||||
|
* an object/array, a partial-JSON string while still streaming, or the raw text
|
||||||
|
* when it cannot be parsed. Blank when there is nothing.
|
||||||
|
*/
|
||||||
|
internal fun prettyToolInput(input: JsonElement?): String = when (input) {
|
||||||
|
null -> ""
|
||||||
|
is JsonObject, is JsonArray -> PRETTY_JSON.encodeToString(JsonElement.serializer(), input)
|
||||||
|
is JsonPrimitive -> input.content
|
||||||
|
else -> input.toString()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The OUTPUT section of a tool call: the concatenated textual content, or the
|
||||||
|
* literal `(no output)` when the call returned nothing (mirroring jarvis), and
|
||||||
|
* an empty string while the call is still running.
|
||||||
|
*/
|
||||||
|
internal fun toolOutputText(state: ChatToolState?): String {
|
||||||
|
if (state == null) return ""
|
||||||
|
val text = state.content
|
||||||
|
.filter { it.type == "text" && it.text.isNotBlank() }
|
||||||
|
.joinToString("\n") { it.text }
|
||||||
|
if (text.isNotBlank()) return text
|
||||||
|
if (ChatProtocol.toolRunning(state)) return ""
|
||||||
|
return "(no output)"
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The ERROR section of a failed tool call. The server's error message takes
|
||||||
|
* precedence over any partial output the call had already produced — a failed
|
||||||
|
* call can carry both, and the output text must not be labelled as the error —
|
||||||
|
* falling back to the output text so the block is never blank when the failure
|
||||||
|
* carries no message.
|
||||||
|
*/
|
||||||
|
internal fun toolErrorText(state: ChatToolState?): String {
|
||||||
|
val message = state?.error?.message
|
||||||
|
return if (!message.isNullOrBlank()) message else toolOutputText(state)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Wall-clock duration of a tool call, or null while it has no completion time. */
|
||||||
|
internal fun toolDurationMillis(part: ChatPart): Long? {
|
||||||
|
val time = part.time ?: return null
|
||||||
|
val start = if (time.ran > 0) time.ran else time.created
|
||||||
|
if (start <= 0 || time.completed <= 0 || time.completed < start) return null
|
||||||
|
return time.completed - start
|
||||||
|
}
|
||||||
|
|
||||||
|
/** True when a tool call ended in an error state. */
|
||||||
|
internal fun toolFailed(state: ChatToolState?): Boolean = state?.status == ChatProtocol.TOOL_ERROR
|
||||||
|
|
||||||
|
/** Compact millisecond duration, e.g. `340ms` / `1.2s` / `2m 3s`. */
|
||||||
|
internal fun formatToolDuration(millis: Long): String = when {
|
||||||
|
millis < 1_000 -> "${millis}ms"
|
||||||
|
millis < 60_000 -> String.format(java.util.Locale.US, "%.1fs", millis / 1000.0)
|
||||||
|
else -> "${millis / 60_000}m ${(millis % 60_000) / 1000}s"
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The chip label for a tool call: its name, or a placeholder when unnamed. */
|
||||||
|
internal fun toolLabel(part: ChatPart): String = part.name.ifBlank { "tool" }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A session's short title: the server title, or a truncated id when untitled, so
|
||||||
|
* a row never renders as a blank line.
|
||||||
|
*/
|
||||||
|
internal fun sessionTitle(session: ChatSession): String =
|
||||||
|
session.title.ifBlank { session.id.take(18).ifBlank { "Untitled chat" } }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The status a session row shows. A locally-running turn is reported as
|
||||||
|
* `Running`; otherwise the server's `busy` flag is `Busy · read-only` (another
|
||||||
|
* client holds it, so the composer is disabled), else `Idle`.
|
||||||
|
*
|
||||||
|
* This is the same precedence [ChatThread.readOnly] applies: a turn we started is
|
||||||
|
* `Running` and writable, never the read-only the server's own `busy` flag alone
|
||||||
|
* would imply.
|
||||||
|
*/
|
||||||
|
internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String = when {
|
||||||
|
runningLocally -> "Running"
|
||||||
|
session.busy -> "Busy · read-only"
|
||||||
|
else -> "Idle"
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Which action the composer's single primary control offers for a chat. */
|
||||||
|
enum class ComposerAction { Send, Stop }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The composer's primary control: while a turn is in flight the send control
|
||||||
|
* becomes the stop control (interrupt), otherwise it sends the draft. One
|
||||||
|
* derivation drives both the trailing button and the keyboard's send action, so
|
||||||
|
* a running turn can never be sent to from the other control.
|
||||||
|
*/
|
||||||
|
internal fun composerAction(thread: ChatThread): ComposerAction =
|
||||||
|
if (thread.running) ComposerAction.Stop else ComposerAction.Send
|
||||||
|
|
||||||
|
/**
|
||||||
|
* One line of a derived unified diff. [CONTEXT] lines are unchanged, [ADD] came
|
||||||
|
* from the edit's `newString` and [REMOVE] from its `oldString`.
|
||||||
|
*/
|
||||||
|
enum class DiffKind { CONTEXT, ADD, REMOVE }
|
||||||
|
|
||||||
|
data class DiffLine(val kind: DiffKind, val text: String)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A synthesised edit diff: the file, the true `+N -M` counts and the ordered
|
||||||
|
* lines. [omitted] is how many diff lines are not in [lines] because the edit was
|
||||||
|
* too large to render in full (0 when the whole diff is shown); the counts always
|
||||||
|
* describe the whole edit, never just the rendered prefix.
|
||||||
|
*/
|
||||||
|
data class ToolDiff(
|
||||||
|
val file: String,
|
||||||
|
val added: Int,
|
||||||
|
val removed: Int,
|
||||||
|
val lines: List<DiffLine>,
|
||||||
|
val omitted: Int = 0,
|
||||||
|
)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Derives a unified diff for an `edit`-family tool call from its
|
||||||
|
* `oldString`/`newString` arguments. The brokered protocol carries no diff field
|
||||||
|
* (research report §2.5), so the +/- view is synthesised here instead. A diff
|
||||||
|
* longer than [MAX_RENDERED_DIFF_LINES] is summarised — only that many lines are
|
||||||
|
* kept, with [ToolDiff.omitted] carrying the rest — so a very large edit cannot
|
||||||
|
* flood the transcript on a phone. Returns null for any other tool, so non-edit
|
||||||
|
* calls keep the INPUT/OUTPUT panel.
|
||||||
|
*/
|
||||||
|
internal fun toolEditDiff(input: JsonElement?): ToolDiff? {
|
||||||
|
val obj = input as? JsonObject ?: return null
|
||||||
|
val old = obj.stringOrNull("oldString", "old_string") ?: return null
|
||||||
|
val new = obj.stringOrNull("newString", "new_string") ?: return null
|
||||||
|
if (old.isEmpty() && new.isEmpty()) return null
|
||||||
|
val lines = lineDiff(old.split("\n"), new.split("\n"))
|
||||||
|
return ToolDiff(
|
||||||
|
file = obj.stringOrNull("filePath", "file_path", "file").orEmpty(),
|
||||||
|
added = lines.count { it.kind == DiffKind.ADD },
|
||||||
|
removed = lines.count { it.kind == DiffKind.REMOVE },
|
||||||
|
lines = lines.take(MAX_RENDERED_DIFF_LINES),
|
||||||
|
omitted = (lines.size - MAX_RENDERED_DIFF_LINES).coerceAtLeast(0),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun JsonObject.stringOrNull(vararg keys: String): String? {
|
||||||
|
for (key in keys) {
|
||||||
|
val value = this[key]
|
||||||
|
if (value is JsonPrimitive && value.isString) return value.content
|
||||||
|
}
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A minimal line diff (LCS) so only the changed lines are marked, not the whole
|
||||||
|
* block. A pathologically large edit falls back to a plain remove-then-add block
|
||||||
|
* to bound the quadratic table.
|
||||||
|
*/
|
||||||
|
private fun lineDiff(old: List<String>, new: List<String>): List<DiffLine> {
|
||||||
|
if (old.size > MAX_DIFF_LINES || new.size > MAX_DIFF_LINES) {
|
||||||
|
return old.map { DiffLine(DiffKind.REMOVE, it) } + new.map { DiffLine(DiffKind.ADD, it) }
|
||||||
|
}
|
||||||
|
val m = old.size
|
||||||
|
val n = new.size
|
||||||
|
val lcs = Array(m + 1) { IntArray(n + 1) }
|
||||||
|
for (i in m - 1 downTo 0) {
|
||||||
|
for (j in n - 1 downTo 0) {
|
||||||
|
lcs[i][j] = if (old[i] == new[j]) lcs[i + 1][j + 1] + 1
|
||||||
|
else maxOf(lcs[i + 1][j], lcs[i][j + 1])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
val result = ArrayList<DiffLine>(m + n)
|
||||||
|
var i = 0
|
||||||
|
var j = 0
|
||||||
|
while (i < m && j < n) {
|
||||||
|
when {
|
||||||
|
old[i] == new[j] -> {
|
||||||
|
result.add(DiffLine(DiffKind.CONTEXT, old[i])); i++; j++
|
||||||
|
}
|
||||||
|
lcs[i + 1][j] >= lcs[i][j + 1] -> {
|
||||||
|
result.add(DiffLine(DiffKind.REMOVE, old[i])); i++
|
||||||
|
}
|
||||||
|
else -> {
|
||||||
|
result.add(DiffLine(DiffKind.ADD, new[j])); j++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (i < m) { result.add(DiffLine(DiffKind.REMOVE, old[i])); i++ }
|
||||||
|
while (j < n) { result.add(DiffLine(DiffKind.ADD, new[j])); j++ }
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* How many diff lines are rendered before the remainder is summarised. Small
|
||||||
|
* enough to stay readable on a phone, large enough that ordinary edits are
|
||||||
|
* always shown in full. [MAX_DIFF_LINES] is the larger algorithm guard that
|
||||||
|
* bounds the quadratic LCS table.
|
||||||
|
*/
|
||||||
|
internal const val MAX_RENDERED_DIFF_LINES = 200
|
||||||
|
|
||||||
|
private const val MAX_DIFF_LINES = 400
|
||||||
|
|
||||||
|
/**
|
||||||
|
* How one permission request stands: still waiting for the operator, answered
|
||||||
|
* here (optimistically, while the reply is in flight), or already settled by the
|
||||||
|
* server (another client answered it, or it expired).
|
||||||
|
*/
|
||||||
|
enum class ApprovalState { PENDING, ANSWERED, RESOLVED }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* What the conversation renders for one permission request. Derived purely from
|
||||||
|
* the server's [ChatPermissionFrame] plus the operator's local answer, so the
|
||||||
|
* approval card and its unit test share one model instead of each reading the
|
||||||
|
* frame. [actionable] is true only while nothing has settled the request, which
|
||||||
|
* is what keeps a resolved request from offering stale once/always/reject
|
||||||
|
* controls.
|
||||||
|
*/
|
||||||
|
data class ApprovalCard(
|
||||||
|
val requestId: String,
|
||||||
|
val action: String,
|
||||||
|
val resources: List<String>,
|
||||||
|
val risk: String,
|
||||||
|
val state: ApprovalState,
|
||||||
|
val decision: String = "",
|
||||||
|
val note: String = "",
|
||||||
|
) {
|
||||||
|
/** The once/always/reject controls are live only while the request is open. */
|
||||||
|
val actionable: Boolean get() = state == ApprovalState.PENDING
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The amber risk box is shown while the request is open and after the
|
||||||
|
* operator denies it (jarvis shows it while "pending/denied"), but not for a
|
||||||
|
* request the server already settled, whose note carries the outcome.
|
||||||
|
*/
|
||||||
|
val showRisk: Boolean
|
||||||
|
get() = state == ApprovalState.PENDING ||
|
||||||
|
(state == ApprovalState.ANSWERED && decision == ChatProtocol.DECISION_REJECT)
|
||||||
|
|
||||||
|
/** The card headline: what is being requested, or the verdict once settled. */
|
||||||
|
val headline: String
|
||||||
|
get() = when (state) {
|
||||||
|
ApprovalState.PENDING -> "Approve " + action.ifBlank { "tool call" }
|
||||||
|
ApprovalState.ANSWERED -> decisionLabel(decision)
|
||||||
|
ApprovalState.RESOLVED -> if (decision.isBlank()) "Already resolved" else decisionLabel(decision)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The one-line explanation under the headline. */
|
||||||
|
val statusLine: String
|
||||||
|
get() = when (state) {
|
||||||
|
ApprovalState.PENDING -> "Waiting for your response"
|
||||||
|
ApprovalState.ANSWERED -> "Waiting for the agent to continue…"
|
||||||
|
ApprovalState.RESOLVED -> note.ifBlank { "Another client already answered this request." }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The approval card for [permission], or null when there is no request to show.
|
||||||
|
* A request the server reports as settled wins over any local answer, so a stale
|
||||||
|
* tap can never reopen controls for a request that is already done.
|
||||||
|
*/
|
||||||
|
internal fun approvalCard(permission: ChatPermissionFrame?, answer: String): ApprovalCard? {
|
||||||
|
if (permission == null || permission.requestId.isBlank()) return null
|
||||||
|
val resolvedByServer = permission.resolved || permission.decision.isNotBlank()
|
||||||
|
val state = when {
|
||||||
|
resolvedByServer -> ApprovalState.RESOLVED
|
||||||
|
answer.isNotBlank() -> ApprovalState.ANSWERED
|
||||||
|
else -> ApprovalState.PENDING
|
||||||
|
}
|
||||||
|
return ApprovalCard(
|
||||||
|
requestId = permission.requestId,
|
||||||
|
action = permission.action,
|
||||||
|
resources = permission.resources.filter { it.isNotBlank() },
|
||||||
|
risk = permissionRiskText(permission),
|
||||||
|
state = state,
|
||||||
|
decision = if (resolvedByServer) permission.decision else answer,
|
||||||
|
note = if (resolvedByServer) permission.message else "",
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The text in the amber risk-review box: the server's own summary when it carries
|
||||||
|
* one (jarvis shows the model's risk summary), otherwise a neutral sentence
|
||||||
|
* naming the action so the box is never blank.
|
||||||
|
*/
|
||||||
|
internal fun permissionRiskText(permission: ChatPermissionFrame): String {
|
||||||
|
if (permission.message.isNotBlank()) return permission.message
|
||||||
|
val what = permission.action.ifBlank { "a tool call" }
|
||||||
|
return "The agent is asking to run $what; review the request before allowing."
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A human label for a once/always/reject decision, blank-safe. */
|
||||||
|
internal fun decisionLabel(decision: String): String = when (decision) {
|
||||||
|
ChatProtocol.DECISION_ONCE -> "Allowed once"
|
||||||
|
ChatProtocol.DECISION_ALWAYS -> "Always allowed"
|
||||||
|
ChatProtocol.DECISION_REJECT -> "Rejected"
|
||||||
|
else -> "Resolved"
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,429 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import kotlinx.coroutines.flow.MutableStateFlow
|
||||||
|
import kotlinx.coroutines.flow.StateFlow
|
||||||
|
import kotlinx.coroutines.flow.asStateFlow
|
||||||
|
import net.awan.pipelines.data.protocol.ChatEventFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatMessage
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPart
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPermissionFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A saved scroll position inside one conversation. Kept as Android-free
|
||||||
|
* primitives so it is part of the pure model and can survive a chat switch (the
|
||||||
|
* caller feeds it back into the list's state).
|
||||||
|
*/
|
||||||
|
data class ChatScrollPosition(val index: Int = 0, val offset: Int = 0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* One open conversation. The conversation itself, whether it is running, its
|
||||||
|
* unsent composer draft and its scroll position all live here, so switching to
|
||||||
|
* another chat and back can never lose any of them.
|
||||||
|
*/
|
||||||
|
data class ChatThread(
|
||||||
|
val sessionId: String,
|
||||||
|
val title: String = "",
|
||||||
|
val directory: String = "",
|
||||||
|
val model: String = "",
|
||||||
|
val agent: String = "",
|
||||||
|
val updatedAt: Long = 0,
|
||||||
|
/** The server reports another client (or an active run) holds this session. */
|
||||||
|
val busy: Boolean = false,
|
||||||
|
val messages: List<ChatMessage> = emptyList(),
|
||||||
|
val loading: Boolean = false,
|
||||||
|
val loaded: Boolean = false,
|
||||||
|
val error: String? = null,
|
||||||
|
/** A turn is in flight for this session; it keeps running when we switch away. */
|
||||||
|
val running: Boolean = false,
|
||||||
|
/**
|
||||||
|
* Wall-clock epoch millis the in-flight turn began, or 0 when it is not
|
||||||
|
* running. Stored on the thread (not in the composable) so the running
|
||||||
|
* indicator's elapsed time survives a chat switch, and cleared the moment
|
||||||
|
* the turn settles.
|
||||||
|
*/
|
||||||
|
val runningSince: Long = 0,
|
||||||
|
/** The unsent composer text for this chat. */
|
||||||
|
val draft: String = "",
|
||||||
|
val scroll: ChatScrollPosition = ChatScrollPosition(),
|
||||||
|
/** The server's pending approval for this session, answered with chat_reply. */
|
||||||
|
val permission: ChatPermissionFrame? = null,
|
||||||
|
/**
|
||||||
|
* The operator's local answer to [permission] (`once`/`always`/`reject`), or
|
||||||
|
* blank while it is still open. Held on the thread so the approval card can
|
||||||
|
* settle in place optimistically and survives a chat switch.
|
||||||
|
*/
|
||||||
|
val permissionAnswer: String = "",
|
||||||
|
) {
|
||||||
|
/**
|
||||||
|
* Read-only while another client holds the session: the composer must never
|
||||||
|
* write to it. A turn we started ourselves keeps the session writable even
|
||||||
|
* though the server reports it busy (the server owns it as our active run),
|
||||||
|
* so the one rule here agrees with [sessionStatusLabel]'s `Running` case.
|
||||||
|
*/
|
||||||
|
val readOnly: Boolean get() = busy && !running
|
||||||
|
|
||||||
|
/** Whether the composer's send action is allowed. */
|
||||||
|
val canSend: Boolean get() = !readOnly && draft.isNotBlank()
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Non-negative elapsed time of an in-flight turn at [nowMillis], or 0 once it
|
||||||
|
* has settled. Pure, so the running indicator and its unit test share the one
|
||||||
|
* derivation instead of each subtracting the start themselves.
|
||||||
|
*/
|
||||||
|
fun elapsedMillis(nowMillis: Long): Long =
|
||||||
|
if (running && runningSince in 1 until nowMillis) nowMillis - runningSince else 0
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The multi-chat screen state. [sessions] is the server's list; [open] is the
|
||||||
|
* ordered set of conversations the operator has opened, each preserved
|
||||||
|
* independently; [activeId] is the one currently on screen.
|
||||||
|
*/
|
||||||
|
data class ChatState(
|
||||||
|
val sessions: List<ChatSession> = emptyList(),
|
||||||
|
val sessionsLoading: Boolean = false,
|
||||||
|
val sessionsLoaded: Boolean = false,
|
||||||
|
val sessionsError: String? = null,
|
||||||
|
val open: List<ChatThread> = emptyList(),
|
||||||
|
val activeId: String? = null,
|
||||||
|
) {
|
||||||
|
val active: ChatThread? get() = open.firstOrNull { it.sessionId == activeId }
|
||||||
|
|
||||||
|
fun thread(sessionId: String): ChatThread? = open.firstOrNull { it.sessionId == sessionId }
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The multi-chat state model: a small, Android-free holder of [ChatState] with
|
||||||
|
* the transitions the chat surface needs. Keeping it free of Compose and of the
|
||||||
|
* transport makes the multi-chat guarantees (per-chat draft/scroll/conversation,
|
||||||
|
* running survives a switch and re-syncs on return) unit-testable without a
|
||||||
|
* device or a server.
|
||||||
|
*
|
||||||
|
* Method contracts that matter:
|
||||||
|
* - [open] and [activate] return true when the caller must (re-)fetch history;
|
||||||
|
* a running session must re-sync on return so a stale copy is never shown.
|
||||||
|
* - [event] applies a server frame to its session's thread whether or not that
|
||||||
|
* thread is on screen, so a background chat never loses its stream.
|
||||||
|
*
|
||||||
|
* [now] is injectable so the running indicator's elapsed time is testable without
|
||||||
|
* a device clock.
|
||||||
|
*/
|
||||||
|
class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||||
|
|
||||||
|
private val _state = MutableStateFlow(ChatState())
|
||||||
|
val state: StateFlow<ChatState> = _state.asStateFlow()
|
||||||
|
|
||||||
|
val value: ChatState get() = _state.value
|
||||||
|
|
||||||
|
// ---- Session list --------------------------------------------------------
|
||||||
|
|
||||||
|
fun sessionsLoading() {
|
||||||
|
_state.value = _state.value.copy(sessionsLoading = true, sessionsError = null)
|
||||||
|
}
|
||||||
|
|
||||||
|
fun sessionsFailed(message: String) {
|
||||||
|
_state.value = _state.value.copy(sessionsLoading = false, sessionsError = message)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Replaces the server's session list and folds its title/busy flags into any
|
||||||
|
* already-open thread, so a status change is reflected without dropping the
|
||||||
|
* conversation. An open thread the server no longer lists is kept (its
|
||||||
|
* conversation is still the operator's).
|
||||||
|
*/
|
||||||
|
fun sessionsLoaded(sessions: List<ChatSession>) {
|
||||||
|
val byId = sessions.associateBy { it.id }
|
||||||
|
val open = _state.value.open.map { thread ->
|
||||||
|
val session = byId[thread.sessionId] ?: return@map thread
|
||||||
|
thread.copy(
|
||||||
|
title = session.title.ifBlank { thread.title },
|
||||||
|
directory = session.directory.ifBlank { thread.directory },
|
||||||
|
busy = session.busy,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
_state.value = _state.value.copy(
|
||||||
|
sessions = sessions,
|
||||||
|
open = open,
|
||||||
|
sessionsLoading = false,
|
||||||
|
sessionsLoaded = true,
|
||||||
|
sessionsError = null,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- Opening / switching -------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Opens [session] (idempotently) and makes it active. Returns true when its
|
||||||
|
* history must be fetched: a brand-new thread always, and a re-opened one
|
||||||
|
* whose state may have moved on (it is running, or was never loaded).
|
||||||
|
*/
|
||||||
|
fun open(session: ChatSession): Boolean {
|
||||||
|
val existing = _state.value.thread(session.id)
|
||||||
|
if (existing == null) {
|
||||||
|
val thread = ChatThread(
|
||||||
|
sessionId = session.id,
|
||||||
|
title = session.title,
|
||||||
|
directory = session.directory,
|
||||||
|
model = session.model,
|
||||||
|
agent = session.agent,
|
||||||
|
updatedAt = session.updatedAt,
|
||||||
|
busy = session.busy,
|
||||||
|
)
|
||||||
|
_state.value = _state.value.copy(open = _state.value.open + thread, activeId = session.id)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
val merged = existing.copy(
|
||||||
|
title = session.title.ifBlank { existing.title },
|
||||||
|
directory = session.directory.ifBlank { existing.directory },
|
||||||
|
busy = session.busy,
|
||||||
|
)
|
||||||
|
_state.value = _state.value.copy(
|
||||||
|
open = _state.value.open.map { if (it.sessionId == session.id) merged else it },
|
||||||
|
activeId = session.id,
|
||||||
|
)
|
||||||
|
return needsResync(merged)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Makes an already-open thread active. Returns true when its history must be
|
||||||
|
* re-fetched first: a running session is re-synced from the server on return
|
||||||
|
* so the operator never sees a stale conversation.
|
||||||
|
*/
|
||||||
|
fun activate(sessionId: String): Boolean {
|
||||||
|
val thread = _state.value.thread(sessionId) ?: return false
|
||||||
|
_state.value = _state.value.copy(activeId = sessionId)
|
||||||
|
return needsResync(thread)
|
||||||
|
}
|
||||||
|
|
||||||
|
fun close(sessionId: String) {
|
||||||
|
val open = _state.value.open.filterNot { it.sessionId == sessionId }
|
||||||
|
val active = if (_state.value.activeId == sessionId) open.lastOrNull()?.sessionId else _state.value.activeId
|
||||||
|
_state.value = _state.value.copy(open = open, activeId = active)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns to the session list without closing any conversation: [activeId]
|
||||||
|
* becomes null while [ChatState.open] is untouched, so every open chat keeps
|
||||||
|
* its messages, draft and scroll.
|
||||||
|
*/
|
||||||
|
fun showList() {
|
||||||
|
if (_state.value.activeId != null) {
|
||||||
|
_state.value = _state.value.copy(activeId = null)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun needsResync(thread: ChatThread): Boolean = thread.running || !thread.loaded
|
||||||
|
|
||||||
|
// ---- Per-thread edits ----------------------------------------------------
|
||||||
|
|
||||||
|
fun draft(sessionId: String, text: String) = update(sessionId) { it.copy(draft = text) }
|
||||||
|
|
||||||
|
fun clearDraft(sessionId: String) = update(sessionId) { it.copy(draft = "") }
|
||||||
|
|
||||||
|
fun scroll(sessionId: String, index: Int, offset: Int) =
|
||||||
|
update(sessionId) { it.copy(scroll = ChatScrollPosition(index, offset)) }
|
||||||
|
|
||||||
|
fun historyLoading(sessionId: String) = update(sessionId) { it.copy(loading = true, error = null) }
|
||||||
|
|
||||||
|
fun failed(sessionId: String, message: String) =
|
||||||
|
update(sessionId) { it.copy(loading = false, error = message) }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Replaces a thread's conversation with the server's authoritative history.
|
||||||
|
* The running flag is left as-is: history alone cannot say whether a turn is
|
||||||
|
* still in flight.
|
||||||
|
*/
|
||||||
|
fun history(sessionId: String, messages: List<ChatMessage>) = update(sessionId) {
|
||||||
|
it.copy(messages = messages, loading = false, loaded = true, error = null)
|
||||||
|
}
|
||||||
|
|
||||||
|
fun running(sessionId: String, running: Boolean) = update(sessionId) { setRunning(it, running) }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The stream resumed (the socket reconnected): every frame that was feeding an
|
||||||
|
* in-flight turn is gone, so no thread keeps claiming to run until a fresh
|
||||||
|
* frame proves otherwise, and the caller re-fetches each open chat's history.
|
||||||
|
* Returning every open id (not only the running ones) means a gap that
|
||||||
|
* silently swallowed the end of a turn is repaired too. Re-fetching replaces
|
||||||
|
* the conversation wholesale, so a resync can neither duplicate nor drop text.
|
||||||
|
*/
|
||||||
|
fun streamResumed(): List<String> {
|
||||||
|
val ids = _state.value.open.map { it.sessionId }
|
||||||
|
if (ids.isEmpty()) return ids
|
||||||
|
_state.value = _state.value.copy(
|
||||||
|
open = _state.value.open.map { if (it.running) it.copy(running = false, runningSince = 0) else it },
|
||||||
|
)
|
||||||
|
return ids
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A server-pushed stream error carries no session id (the brokered protocol
|
||||||
|
* cannot attribute it), so settle the one turn it can only have come from: the
|
||||||
|
* sole running chat, or the active one when several are in flight. With
|
||||||
|
* nothing running there is no turn to settle and it is ignored; the server's
|
||||||
|
* text is kept so the operator sees why the turn stopped.
|
||||||
|
*/
|
||||||
|
fun streamError(message: String) {
|
||||||
|
val running = _state.value.open.filter { it.running }
|
||||||
|
val target = when {
|
||||||
|
running.isEmpty() -> return
|
||||||
|
running.size == 1 -> running.single()
|
||||||
|
else -> running.firstOrNull { it.sessionId == _state.value.activeId } ?: return
|
||||||
|
}
|
||||||
|
update(target.sessionId) { setRunning(it.copy(error = message), false) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The server pushed an approval request for this session, or reported one it
|
||||||
|
* has already settled. A frame for a *new* request replaces any leftover card
|
||||||
|
* from the previous one; a frame for the same request (for example a resolved
|
||||||
|
* re-push) keeps the local answer and applies the server's outcome.
|
||||||
|
*/
|
||||||
|
fun permission(frame: ChatPermissionFrame) {
|
||||||
|
if (frame.sessionId.isBlank()) return
|
||||||
|
ensureThread(frame.sessionId)
|
||||||
|
update(frame.sessionId) {
|
||||||
|
val sameRequest = it.permission?.requestId == frame.requestId && frame.requestId.isNotBlank()
|
||||||
|
it.copy(
|
||||||
|
permission = frame,
|
||||||
|
permissionAnswer = if (sameRequest) it.permissionAnswer else "",
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The operator's decision on the pending request, recorded optimistically so
|
||||||
|
* the card settles in place before the round-trip: the buttons are never left
|
||||||
|
* offering a decision already made. A request that is no longer the one on
|
||||||
|
* screen is ignored.
|
||||||
|
*/
|
||||||
|
fun answerPermission(sessionId: String, requestId: String, decision: String) = update(sessionId) {
|
||||||
|
if (it.permission?.requestId != requestId) it else it.copy(permissionAnswer = decision)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The reply failed: reopen the same request so the operator can try again. */
|
||||||
|
fun permissionReplyFailed(sessionId: String, requestId: String) = update(sessionId) {
|
||||||
|
if (it.permission?.requestId != requestId) it else it.copy(permissionAnswer = "")
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Appends the operator's just-sent prompt optimistically, so the bubble is
|
||||||
|
* visible before the ack and history round-trip. History later reconciles it.
|
||||||
|
*/
|
||||||
|
fun appendLocalUserMessage(sessionId: String, text: String) = update(sessionId) {
|
||||||
|
val message = ChatMessage(
|
||||||
|
id = LOCAL_MESSAGE_PREFIX + (it.messages.count { m -> m.id.startsWith(LOCAL_MESSAGE_PREFIX) } + 1),
|
||||||
|
sessionId = sessionId,
|
||||||
|
role = ChatProtocol.ROLE_USER,
|
||||||
|
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = text)),
|
||||||
|
)
|
||||||
|
it.copy(messages = it.messages + message)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- Streaming events ----------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Folds one pushed [frame] into its session's thread, creating a placeholder
|
||||||
|
* thread when the frame arrives for a chat that is not open, so a background
|
||||||
|
* chat keeps its stream instead of dropping it.
|
||||||
|
*/
|
||||||
|
fun event(frame: ChatEventFrame) {
|
||||||
|
if (frame.sessionId.isBlank()) return
|
||||||
|
ensureThread(frame.sessionId)
|
||||||
|
when (frame.kind) {
|
||||||
|
ChatProtocol.PART_TEXT, ChatProtocol.PART_REASONING -> applyDelta(frame)
|
||||||
|
ChatProtocol.PART_TOOL -> applyTool(frame)
|
||||||
|
ChatProtocol.EVENT_STEP -> {
|
||||||
|
val started = frame.step?.status != ChatProtocol.STEP_ENDED
|
||||||
|
update(frame.sessionId) { setRunning(it, started) }
|
||||||
|
}
|
||||||
|
else -> Unit
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Creates a placeholder thread for a session that is not open, so a frame for
|
||||||
|
* a background chat is kept instead of dropped. A no-op when it already exists.
|
||||||
|
*/
|
||||||
|
private fun ensureThread(sessionId: String) {
|
||||||
|
if (_state.value.thread(sessionId) != null) return
|
||||||
|
val session = _state.value.sessions.firstOrNull { it.id == sessionId }
|
||||||
|
val placeholder = ChatThread(
|
||||||
|
sessionId = sessionId,
|
||||||
|
title = session?.title ?: "",
|
||||||
|
directory = session?.directory ?: "",
|
||||||
|
busy = session?.busy ?: false,
|
||||||
|
)
|
||||||
|
_state.value = _state.value.copy(open = _state.value.open + placeholder)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyDelta(frame: ChatEventFrame) {
|
||||||
|
val partId = frame.part?.id.orEmpty()
|
||||||
|
if (partId.isEmpty() || frame.delta.isEmpty()) return
|
||||||
|
upsertPart(frame, partId) { existing ->
|
||||||
|
existing?.copy(text = existing.text + frame.delta)
|
||||||
|
?: ChatPart(type = frame.kind, id = partId, text = frame.delta)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyTool(frame: ChatEventFrame) {
|
||||||
|
val part = frame.part ?: return
|
||||||
|
if (part.id.isEmpty()) return
|
||||||
|
upsertPart(frame, part.id) { part }
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Finds or creates the assistant message [frame] targets and the part [partId]
|
||||||
|
* inside it, replacing it via [upsert] (the old part when it exists, else
|
||||||
|
* null), then marks the thread running. The text/reasoning delta and the tool
|
||||||
|
* upsert share this so the two cannot drift.
|
||||||
|
*/
|
||||||
|
private fun upsertPart(frame: ChatEventFrame, partId: String, upsert: (ChatPart?) -> ChatPart) {
|
||||||
|
update(frame.sessionId) { thread ->
|
||||||
|
val messages = thread.messages.toMutableList()
|
||||||
|
val index = messages.indexOfLast { it.id == frame.messageId }
|
||||||
|
val message = if (index >= 0) {
|
||||||
|
messages[index]
|
||||||
|
} else {
|
||||||
|
ChatMessage(
|
||||||
|
id = frame.messageId,
|
||||||
|
sessionId = frame.sessionId,
|
||||||
|
role = ChatProtocol.ROLE_ASSISTANT,
|
||||||
|
).also { messages.add(it) }
|
||||||
|
}
|
||||||
|
val resolvedIndex = if (index >= 0) index else messages.lastIndex
|
||||||
|
val parts = message.parts.toMutableList()
|
||||||
|
val partIndex = parts.indexOfFirst { it.id == partId }
|
||||||
|
val updated = upsert(if (partIndex >= 0) parts[partIndex] else null)
|
||||||
|
if (partIndex >= 0) parts[partIndex] = updated else parts.add(updated)
|
||||||
|
messages[resolvedIndex] = message.copy(parts = parts)
|
||||||
|
setRunning(thread.copy(messages = messages), true)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Applies a running transition: a turn that begins is stamped with the wall
|
||||||
|
* clock so the indicator can tick, a redundant `true` keeps the original
|
||||||
|
* stamp, and settling clears it. The one place `running` is set, so the two
|
||||||
|
* can never disagree.
|
||||||
|
*/
|
||||||
|
private fun setRunning(thread: ChatThread, running: Boolean): ChatThread = when {
|
||||||
|
running && !thread.running -> thread.copy(running = true, runningSince = now())
|
||||||
|
running -> thread
|
||||||
|
else -> thread.copy(running = false, runningSince = 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun update(sessionId: String, block: (ChatThread) -> ChatThread) {
|
||||||
|
val current = _state.value
|
||||||
|
if (current.open.none { it.sessionId == sessionId }) return
|
||||||
|
_state.value = current.copy(
|
||||||
|
open = current.open.map { if (it.sessionId == sessionId) block(it) else it },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
const val LOCAL_MESSAGE_PREFIX = "local-"
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,463 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import androidx.compose.foundation.background
|
||||||
|
import androidx.compose.foundation.border
|
||||||
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
|
import androidx.compose.foundation.layout.Box
|
||||||
|
import androidx.compose.foundation.layout.Column
|
||||||
|
import androidx.compose.foundation.layout.IntrinsicSize
|
||||||
|
import androidx.compose.foundation.layout.Row
|
||||||
|
import androidx.compose.foundation.layout.fillMaxHeight
|
||||||
|
import androidx.compose.foundation.layout.fillMaxWidth
|
||||||
|
import androidx.compose.foundation.layout.height
|
||||||
|
import androidx.compose.foundation.layout.padding
|
||||||
|
import androidx.compose.foundation.layout.width
|
||||||
|
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||||
|
import androidx.compose.material3.HorizontalDivider
|
||||||
|
import androidx.compose.material3.MaterialTheme
|
||||||
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.runtime.Composable
|
||||||
|
import androidx.compose.runtime.remember
|
||||||
|
import androidx.compose.ui.Modifier
|
||||||
|
import androidx.compose.ui.draw.clip
|
||||||
|
import androidx.compose.ui.graphics.Color
|
||||||
|
import androidx.compose.ui.text.AnnotatedString
|
||||||
|
import androidx.compose.ui.text.LinkAnnotation
|
||||||
|
import androidx.compose.ui.text.SpanStyle
|
||||||
|
import androidx.compose.ui.text.TextLinkStyles
|
||||||
|
import androidx.compose.ui.text.buildAnnotatedString
|
||||||
|
import androidx.compose.ui.text.font.FontFamily
|
||||||
|
import androidx.compose.ui.text.font.FontStyle
|
||||||
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
|
import androidx.compose.ui.text.style.TextDecoration
|
||||||
|
import androidx.compose.ui.text.style.TextOverflow
|
||||||
|
import androidx.compose.ui.text.withLink
|
||||||
|
import androidx.compose.ui.text.withStyle
|
||||||
|
import androidx.compose.ui.unit.dp
|
||||||
|
import net.awan.pipelines.ui.components.CodeBlock
|
||||||
|
import net.awan.pipelines.ui.theme.HAIRLINE_DP
|
||||||
|
import net.awan.pipelines.ui.theme.pipelinesText
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A small, dependency-free CommonMark subset for assistant prose. The brokered
|
||||||
|
* protocol carries assistant text as markdown and the reference experience renders
|
||||||
|
* it (research §1.2): body paragraphs, `#`..`######` headings, fenced code (the
|
||||||
|
* shared [CodeBlock], so the copy action comes for free), block quotes, bullet and
|
||||||
|
* ordered lists, `|` tables, thematic rules, and inline code / bold / italic /
|
||||||
|
* links. Anything outside the subset renders as plain text, never dropped.
|
||||||
|
*
|
||||||
|
* The parser is pure Kotlin (no Compose, no transport) so it is unit-testable; the
|
||||||
|
* composables below turn the same blocks into themed, selectable content.
|
||||||
|
*/
|
||||||
|
|
||||||
|
// ---- Parsed model ------------------------------------------------------------
|
||||||
|
|
||||||
|
internal sealed interface MdBlock
|
||||||
|
|
||||||
|
internal data class MdHeading(val level: Int, val text: String) : MdBlock
|
||||||
|
internal data class MdParagraph(val text: String) : MdBlock
|
||||||
|
internal data class MdCodeBlock(val language: String, val code: String) : MdBlock
|
||||||
|
internal data class MdQuote(val lines: List<String>) : MdBlock
|
||||||
|
internal data class MdListBlock(val ordered: Boolean, val items: List<String>) : MdBlock
|
||||||
|
internal data class MdTableBlock(val header: List<String>, val rows: List<List<String>>) : MdBlock
|
||||||
|
internal data object MdRule : MdBlock
|
||||||
|
|
||||||
|
internal sealed interface MdSpan
|
||||||
|
|
||||||
|
internal data class MdPlain(val text: String) : MdSpan
|
||||||
|
internal data class MdCodeSpan(val text: String) : MdSpan
|
||||||
|
internal data class MdStrong(val spans: List<MdSpan>) : MdSpan
|
||||||
|
internal data class MdEmphasis(val spans: List<MdSpan>) : MdSpan
|
||||||
|
internal data class MdLinkSpan(val spans: List<MdSpan>, val url: String) : MdSpan
|
||||||
|
|
||||||
|
// ---- Block parser ------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Parses [source] into the block list the renderer walks. Never throws. */
|
||||||
|
internal fun parseMarkdown(source: String): List<MdBlock> {
|
||||||
|
val lines = source.replace("\r\n", "\n").replace('\r', '\n').split('\n')
|
||||||
|
val blocks = mutableListOf<MdBlock>()
|
||||||
|
var i = 0
|
||||||
|
while (i < lines.size) {
|
||||||
|
val line = lines[i]
|
||||||
|
val trimmed = line.trim()
|
||||||
|
when {
|
||||||
|
trimmed.isEmpty() -> i++
|
||||||
|
|
||||||
|
fenceRun(trimmed) != null -> {
|
||||||
|
val fence = fenceRun(trimmed)!!
|
||||||
|
val language = trimmed.removePrefix(fence).trim().substringBefore(' ')
|
||||||
|
val code = mutableListOf<String>()
|
||||||
|
i++
|
||||||
|
while (i < lines.size && fenceRun(lines[i].trim()) == null) {
|
||||||
|
code.add(lines[i])
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
if (i < lines.size) i++ // consume the closing fence
|
||||||
|
blocks.add(MdCodeBlock(language, code.joinToString("\n")))
|
||||||
|
}
|
||||||
|
|
||||||
|
headingLevel(trimmed) > 0 -> {
|
||||||
|
val level = headingLevel(trimmed)
|
||||||
|
blocks.add(MdHeading(level, trimmed.drop(level).trim().trimEnd('#')))
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
|
||||||
|
isRule(trimmed) -> {
|
||||||
|
blocks.add(MdRule)
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
|
||||||
|
trimmed.startsWith(">") -> {
|
||||||
|
val quote = mutableListOf<String>()
|
||||||
|
while (i < lines.size && lines[i].trim().startsWith(">")) {
|
||||||
|
quote.add(lines[i].trim().removePrefix(">").removePrefix(" ").trimEnd())
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
blocks.add(MdQuote(quote))
|
||||||
|
}
|
||||||
|
|
||||||
|
isTableStart(lines, i) -> {
|
||||||
|
val header = splitRow(lines[i])
|
||||||
|
i += 2 // header + delimiter row
|
||||||
|
val rows = mutableListOf<List<String>>()
|
||||||
|
while (i < lines.size && lines[i].contains('|') && lines[i].isNotBlank()) {
|
||||||
|
rows.add(fitRow(splitRow(lines[i]), header.size))
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
blocks.add(MdTableBlock(header, rows))
|
||||||
|
}
|
||||||
|
|
||||||
|
listMarker(line) != null -> {
|
||||||
|
val ordered = listMarker(line)!!.first
|
||||||
|
val items = mutableListOf<String>()
|
||||||
|
while (i < lines.size && listMarker(lines[i])?.first == ordered) {
|
||||||
|
items.add(listMarker(lines[i])!!.second)
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
blocks.add(MdListBlock(ordered, items))
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
val paragraph = mutableListOf(line.trim())
|
||||||
|
i++
|
||||||
|
while (i < lines.size && lines[i].isNotBlank() && !startsBlock(lines, i)) {
|
||||||
|
paragraph.add(lines[i].trim())
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
blocks.add(MdParagraph(paragraph.joinToString(" ")))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return blocks
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The fence run (` ``` ` / `~~~`) a line opens or closes with, or null. */
|
||||||
|
private fun fenceRun(trimmed: String): String? {
|
||||||
|
val first = trimmed.firstOrNull() ?: return null
|
||||||
|
if (first != '`' && first != '~') return null
|
||||||
|
val run = trimmed.takeWhile { it == first }
|
||||||
|
return if (run.length >= 3) run else null
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun headingLevel(trimmed: String): Int {
|
||||||
|
val hashes = trimmed.takeWhile { it == '#' }.length
|
||||||
|
if (hashes == 0 || hashes > 6) return 0
|
||||||
|
return if (trimmed.length == hashes || trimmed[hashes] == ' ') hashes else 0
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun isRule(trimmed: String): Boolean =
|
||||||
|
trimmed.length >= 3 && trimmed.all { it == trimmed[0] } && trimmed[0] in "-*_"
|
||||||
|
|
||||||
|
/** True when [lines] at [index] is a table header followed by a `---` delimiter row. */
|
||||||
|
private fun isTableStart(lines: List<String>, index: Int): Boolean {
|
||||||
|
if (index + 1 >= lines.size || !lines[index].contains('|')) return false
|
||||||
|
val delimiter = splitRow(lines[index + 1])
|
||||||
|
if (delimiter.isEmpty() || splitRow(lines[index]).size < 2) return false
|
||||||
|
return delimiter.all { cell -> cell.isNotEmpty() && cell.all { it == '-' || it == ':' } && cell.contains('-') }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Splits a table row on unescaped `|`, dropping the leading/trailing empty cell. */
|
||||||
|
private fun splitRow(line: String): List<String> =
|
||||||
|
line.trim().removePrefix("|").removeSuffix("|").split('|').map { it.replace("\\|", "|").trim() }
|
||||||
|
|
||||||
|
private fun fitRow(row: List<String>, size: Int): List<String> =
|
||||||
|
List(size) { row.getOrElse(it) { "" } }
|
||||||
|
|
||||||
|
/** The ordered flag and item text of a list line, or null for a non-item line. */
|
||||||
|
private fun listMarker(line: String): Pair<Boolean, String>? {
|
||||||
|
val trimmed = line.trimStart()
|
||||||
|
val orderedMatch = ORDERED_ITEM.matchEntire(trimmed)
|
||||||
|
if (orderedMatch != null) return true to orderedMatch.groupValues[2]
|
||||||
|
val bulletMatch = BULLET_ITEM.matchEntire(trimmed)
|
||||||
|
if (bulletMatch != null) return false to bulletMatch.groupValues[2]
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
/** True when [lines] at [index] begins a block that must interrupt a paragraph. */
|
||||||
|
private fun startsBlock(lines: List<String>, index: Int): Boolean {
|
||||||
|
val trimmed = lines[index].trim()
|
||||||
|
return fenceRun(trimmed) != null ||
|
||||||
|
headingLevel(trimmed) > 0 ||
|
||||||
|
isRule(trimmed) ||
|
||||||
|
trimmed.startsWith(">") ||
|
||||||
|
listMarker(lines[index]) != null ||
|
||||||
|
isTableStart(lines, index)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- Inline parser -----------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Parses inline markup in [text] into a flat span tree. Handles `` `code` ``,
|
||||||
|
* `**bold**` / `__bold__`, `*italic*` / `_italic_`, `[label](url)` and bare
|
||||||
|
* `http(s)://` autolinks; everything else stays plain text. Underscore emphasis
|
||||||
|
* requires word boundaries so `snake_case` is never italicised.
|
||||||
|
*/
|
||||||
|
internal fun parseInline(text: String): List<MdSpan> {
|
||||||
|
val spans = mutableListOf<MdSpan>()
|
||||||
|
val buffer = StringBuilder()
|
||||||
|
var i = 0
|
||||||
|
|
||||||
|
fun flush() {
|
||||||
|
if (buffer.isNotEmpty()) {
|
||||||
|
spans.add(MdPlain(buffer.toString()))
|
||||||
|
buffer.clear()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
while (i < text.length) {
|
||||||
|
val c = text[i]
|
||||||
|
when {
|
||||||
|
c == '`' -> {
|
||||||
|
val end = text.indexOf('`', i + 1)
|
||||||
|
if (end > i) {
|
||||||
|
flush()
|
||||||
|
spans.add(MdCodeSpan(text.substring(i + 1, end)))
|
||||||
|
i = end + 1
|
||||||
|
} else {
|
||||||
|
buffer.append(c); i++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
c == '*' || c == '_' -> {
|
||||||
|
val doubled = i + 1 < text.length && text[i + 1] == c
|
||||||
|
val marker = if (doubled) "$c$c" else c.toString()
|
||||||
|
val boundOk = c != '_' || i == 0 || !text[i - 1].isLetterOrDigit()
|
||||||
|
val end = if (boundOk) text.indexOf(marker, i + marker.length) else -1
|
||||||
|
val closes = end > i + marker.length &&
|
||||||
|
(c != '_' || end + 1 >= text.length || !text[end + 1].isLetterOrDigit())
|
||||||
|
if (closes) {
|
||||||
|
flush()
|
||||||
|
val inner = parseInline(text.substring(i + marker.length, end))
|
||||||
|
spans.add(if (doubled) MdStrong(inner) else MdEmphasis(inner))
|
||||||
|
i = end + marker.length
|
||||||
|
} else {
|
||||||
|
buffer.append(c); i++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
c == '[' -> {
|
||||||
|
val close = text.indexOf(']', i + 1)
|
||||||
|
if (close > i && close + 1 < text.length && text[close + 1] == '(') {
|
||||||
|
val urlEnd = text.indexOf(')', close + 2)
|
||||||
|
val url = if (urlEnd > close) text.substring(close + 2, urlEnd).trim() else ""
|
||||||
|
if (url.isNotEmpty()) {
|
||||||
|
flush()
|
||||||
|
spans.add(MdLinkSpan(parseInline(text.substring(i + 1, close)), url))
|
||||||
|
i = urlEnd + 1
|
||||||
|
} else {
|
||||||
|
buffer.append(c); i++
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
buffer.append(c); i++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
val url = autolinkAt(text, i)
|
||||||
|
if (url != null) {
|
||||||
|
flush()
|
||||||
|
spans.add(MdLinkSpan(listOf(MdPlain(url)), url))
|
||||||
|
i += url.length
|
||||||
|
} else {
|
||||||
|
buffer.append(c); i++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
flush()
|
||||||
|
return spans
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A bare `http(s)://` URL starting exactly at [index], trailing punctuation trimmed. */
|
||||||
|
private fun autolinkAt(text: String, index: Int): String? {
|
||||||
|
if (!text.startsWith("http://", index) && !text.startsWith("https://", index)) return null
|
||||||
|
var end = index
|
||||||
|
while (end < text.length && !text[end].isWhitespace() && text[end] !in "<>\"'") end++
|
||||||
|
var url = text.substring(index, end)
|
||||||
|
while (url.isNotEmpty() && url.last() in ".,;:!?)]}") url = url.dropLast(1)
|
||||||
|
return url.takeIf { it.length > "https://".length }
|
||||||
|
}
|
||||||
|
|
||||||
|
private val ORDERED_ITEM = Regex("""^(\d{1,9})[.)]\s+(.*)$""")
|
||||||
|
private val BULLET_ITEM = Regex("""^([-*+])\s+(.*)$""")
|
||||||
|
|
||||||
|
// ---- Renderers ---------------------------------------------------------------
|
||||||
|
|
||||||
|
private val MD_QUOTE_BAR = 3.dp
|
||||||
|
private val MD_TABLE_BORDER = HAIRLINE_DP
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Renders [text] as markdown at the app's shared body style. The caller owns the
|
||||||
|
* selection container (a chat message is one selectable region), so this only
|
||||||
|
* lays out the blocks.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
internal fun MarkdownText(text: String, modifier: Modifier = Modifier) {
|
||||||
|
val blocks = remember(text) { parseMarkdown(text) }
|
||||||
|
Column(modifier, verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
|
||||||
|
blocks.forEach { MarkdownBlock(it) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun MarkdownBlock(block: MdBlock) {
|
||||||
|
val texts = pipelinesText()
|
||||||
|
when (block) {
|
||||||
|
is MdHeading -> Text(
|
||||||
|
text = inline(block.text),
|
||||||
|
style = when (block.level) {
|
||||||
|
1 -> MaterialTheme.typography.titleLarge
|
||||||
|
2 -> MaterialTheme.typography.titleMedium
|
||||||
|
else -> texts.cardTitle
|
||||||
|
},
|
||||||
|
color = MaterialTheme.colorScheme.onSurface,
|
||||||
|
)
|
||||||
|
|
||||||
|
is MdParagraph -> Text(text = inline(block.text), style = texts.body)
|
||||||
|
|
||||||
|
is MdCodeBlock -> CodeBlock(label = block.language.ifBlank { "code" }, text = block.code)
|
||||||
|
|
||||||
|
MdRule -> HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
|
||||||
|
|
||||||
|
is MdQuote -> Row(Modifier.height(IntrinsicSize.Min)) {
|
||||||
|
Box(
|
||||||
|
Modifier
|
||||||
|
.width(MD_QUOTE_BAR)
|
||||||
|
.fillMaxHeight()
|
||||||
|
.background(MaterialTheme.colorScheme.outlineVariant),
|
||||||
|
)
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.padding(start = CHAT_ITEM_GAP),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP / 2),
|
||||||
|
) {
|
||||||
|
block.lines.forEach { line ->
|
||||||
|
if (line.isNotBlank()) {
|
||||||
|
Text(
|
||||||
|
text = inline(line),
|
||||||
|
style = texts.body,
|
||||||
|
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is MdListBlock -> Column(verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP / 2)) {
|
||||||
|
block.items.forEachIndexed { index, item ->
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
|
||||||
|
Text(
|
||||||
|
text = if (block.ordered) "${index + 1}." else "•",
|
||||||
|
style = texts.body,
|
||||||
|
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||||
|
)
|
||||||
|
Text(text = inline(item), style = texts.body)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is MdTableBlock -> MarkdownTable(block)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun MarkdownTable(table: MdTableBlock) {
|
||||||
|
val border = MaterialTheme.colorScheme.outlineVariant
|
||||||
|
val shape = RoundedCornerShape(CHAT_ITEM_GAP)
|
||||||
|
Column(
|
||||||
|
Modifier
|
||||||
|
.fillMaxWidth()
|
||||||
|
.clip(shape)
|
||||||
|
.border(MD_TABLE_BORDER, border, shape),
|
||||||
|
) {
|
||||||
|
TableRow(table.header, header = true, border = border)
|
||||||
|
table.rows.forEach { row ->
|
||||||
|
HorizontalDivider(color = border)
|
||||||
|
TableRow(row, header = false, border = border)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun TableRow(cells: List<String>, header: Boolean, border: Color) {
|
||||||
|
val texts = pipelinesText()
|
||||||
|
Row(Modifier.fillMaxWidth().height(IntrinsicSize.Min)) {
|
||||||
|
cells.forEachIndexed { index, cell ->
|
||||||
|
if (index > 0) {
|
||||||
|
Box(Modifier.width(MD_TABLE_BORDER).fillMaxHeight().background(border))
|
||||||
|
}
|
||||||
|
Text(
|
||||||
|
text = inline(cell),
|
||||||
|
style = if (header) texts.body.copy(fontWeight = FontWeight.Bold) else texts.body,
|
||||||
|
modifier = Modifier.weight(1f).padding(CHAT_ITEM_GAP),
|
||||||
|
maxLines = if (header) 1 else Int.MAX_VALUE,
|
||||||
|
overflow = TextOverflow.Ellipsis,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Inline text as one [AnnotatedString]; links are tappable and code is monospace. */
|
||||||
|
@Composable
|
||||||
|
private fun inline(text: String): AnnotatedString {
|
||||||
|
val linkColor = MaterialTheme.colorScheme.primary
|
||||||
|
val codeBackground = MaterialTheme.colorScheme.surfaceContainerHigh
|
||||||
|
val codeColor = MaterialTheme.colorScheme.onSurface
|
||||||
|
return remember(text, linkColor, codeBackground, codeColor) {
|
||||||
|
buildInline(parseInline(text), linkColor, codeBackground, codeColor)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildInline(
|
||||||
|
spans: List<MdSpan>,
|
||||||
|
linkColor: Color,
|
||||||
|
codeBackground: Color,
|
||||||
|
codeColor: Color,
|
||||||
|
): AnnotatedString = buildAnnotatedString { appendSpans(spans, linkColor, codeBackground, codeColor) }
|
||||||
|
|
||||||
|
private fun androidx.compose.ui.text.AnnotatedString.Builder.appendSpans(
|
||||||
|
spans: List<MdSpan>,
|
||||||
|
linkColor: Color,
|
||||||
|
codeBackground: Color,
|
||||||
|
codeColor: Color,
|
||||||
|
) {
|
||||||
|
for (span in spans) {
|
||||||
|
when (span) {
|
||||||
|
is MdPlain -> append(span.text)
|
||||||
|
is MdCodeSpan -> withStyle(
|
||||||
|
SpanStyle(fontFamily = FontFamily.Monospace, background = codeBackground, color = codeColor),
|
||||||
|
) { append(span.text) }
|
||||||
|
is MdStrong -> withStyle(SpanStyle(fontWeight = FontWeight.Bold)) {
|
||||||
|
appendSpans(span.spans, linkColor, codeBackground, codeColor)
|
||||||
|
}
|
||||||
|
is MdEmphasis -> withStyle(SpanStyle(fontStyle = FontStyle.Italic)) {
|
||||||
|
appendSpans(span.spans, linkColor, codeBackground, codeColor)
|
||||||
|
}
|
||||||
|
is MdLinkSpan -> withLink(
|
||||||
|
LinkAnnotation.Url(
|
||||||
|
span.url,
|
||||||
|
TextLinkStyles(style = SpanStyle(color = linkColor, textDecoration = TextDecoration.Underline)),
|
||||||
|
),
|
||||||
|
) { appendSpans(span.spans, linkColor, codeBackground, codeColor) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -212,3 +212,18 @@ internal val STAGE_CHIP_PAD_H = 10.dp
|
|||||||
|
|
||||||
/** The omni-search panel's inline progress spinner. */
|
/** The omni-search panel's inline progress spinner. */
|
||||||
internal val SEARCH_PROGRESS_DP = 18.dp
|
internal val SEARCH_PROGRESS_DP = 18.dp
|
||||||
|
|
||||||
|
/** The thinnest line the UI draws - a table border, a divider or a card outline. */
|
||||||
|
internal val HAIRLINE_DP = 1.dp
|
||||||
|
|
||||||
|
/** A small icon button: the session close action and the tool-panel dismiss. */
|
||||||
|
internal val ICON_BUTTON_SMALL_DP = 28.dp
|
||||||
|
|
||||||
|
/** The floating tool panel's maximum width; it floats over the transcript. */
|
||||||
|
internal val TOOL_PANEL_MAX_WIDTH_DP = 420.dp
|
||||||
|
|
||||||
|
/** A chat row's title column stops here so the close action keeps its place. */
|
||||||
|
internal val CHAT_TITLE_MAX_WIDTH_DP = 160.dp
|
||||||
|
|
||||||
|
/** A chat message bubble's maximum width, so long prose stays readable. */
|
||||||
|
internal val CHAT_BUBBLE_MAX_WIDTH_DP = 560.dp
|
||||||
|
|||||||
@@ -0,0 +1,258 @@
|
|||||||
|
package net.awan.pipelines.data.protocol
|
||||||
|
|
||||||
|
import kotlinx.serialization.json.JsonObject
|
||||||
|
import kotlinx.serialization.json.JsonPrimitive
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
class ChatProtocolTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun chatSessionsParseWithBusyFlagAndFlattenedFields() {
|
||||||
|
val json = """
|
||||||
|
{
|
||||||
|
"type": "chat_sessions",
|
||||||
|
"id": "android-1",
|
||||||
|
"chat_sessions": [
|
||||||
|
{
|
||||||
|
"id": "ses_abc",
|
||||||
|
"title": "Fix the parser",
|
||||||
|
"agent": "build",
|
||||||
|
"model": "deepseek-v4.1-flash",
|
||||||
|
"directory": "/Users/alan/repos/pipelines",
|
||||||
|
"parent_id": "",
|
||||||
|
"created_at": 1792112366711,
|
||||||
|
"updated_at": 1792112367036,
|
||||||
|
"busy": true
|
||||||
|
},
|
||||||
|
{"id": "ses_def", "title": "Second chat"}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
""".trimIndent()
|
||||||
|
val message = PipelinesJson.decodeFromString(Message.serializer(), json)
|
||||||
|
assertEquals(Protocol.CHAT_SESSIONS, message.type)
|
||||||
|
val sessions = message.chatSessions!!
|
||||||
|
assertEquals(2, sessions.size)
|
||||||
|
val first = sessions.first()
|
||||||
|
assertEquals("ses_abc", first.id)
|
||||||
|
assertEquals("Fix the parser", first.title)
|
||||||
|
assertEquals("/Users/alan/repos/pipelines", first.directory)
|
||||||
|
assertEquals(1792112366711L, first.createdAt)
|
||||||
|
assertTrue(first.busy)
|
||||||
|
// An absent busy key defaults to false, never a crash.
|
||||||
|
assertTrue(!sessions[1].busy)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun chatMessagesParseTextReasoningAndToolParts() {
|
||||||
|
val json = """
|
||||||
|
{
|
||||||
|
"type": "chat_messages",
|
||||||
|
"chat_messages": [
|
||||||
|
{
|
||||||
|
"id": "msg_user",
|
||||||
|
"session_id": "ses_abc",
|
||||||
|
"role": "user",
|
||||||
|
"parts": [{"type": "text", "id": "p1", "text": "hello"}]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"id": "msg_asst",
|
||||||
|
"session_id": "ses_abc",
|
||||||
|
"role": "assistant",
|
||||||
|
"parts": [
|
||||||
|
{"type": "reasoning", "id": "r1", "text": "thinking"},
|
||||||
|
{"type": "text", "id": "t1", "text": "done"},
|
||||||
|
{
|
||||||
|
"type": "tool",
|
||||||
|
"id": "call_1",
|
||||||
|
"name": "shell",
|
||||||
|
"executed": false,
|
||||||
|
"state": {
|
||||||
|
"status": "completed",
|
||||||
|
"input": {"command": "ls"},
|
||||||
|
"content": [{"type": "text", "text": "a.txt"}],
|
||||||
|
"metadata": {"exit": 0},
|
||||||
|
"error": null
|
||||||
|
},
|
||||||
|
"time": {"created": 10, "ran": 12, "completed": 20}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
""".trimIndent()
|
||||||
|
val messages = PipelinesJson.decodeFromString(Message.serializer(), json).chatMessages!!
|
||||||
|
assertEquals(2, messages.size)
|
||||||
|
assertEquals(ChatProtocol.ROLE_USER, messages[0].role)
|
||||||
|
assertEquals("hello", messages[0].parts.single().text)
|
||||||
|
val assistant = messages[1]
|
||||||
|
assertEquals(ChatProtocol.PART_REASONING, assistant.parts[0].type)
|
||||||
|
val tool = assistant.parts.first { it.type == ChatProtocol.PART_TOOL }
|
||||||
|
assertEquals("shell", tool.name)
|
||||||
|
assertEquals(ChatProtocol.TOOL_COMPLETED, tool.state!!.status)
|
||||||
|
assertTrue(tool.state!!.input is JsonObject)
|
||||||
|
assertEquals("a.txt", tool.state!!.content.single().text)
|
||||||
|
assertEquals(8L, toolDuration(tool))
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The tool input is a partial-JSON string while streaming and an object afterwards. */
|
||||||
|
@Test
|
||||||
|
fun streamingToolInputIsAStringAndCompletedInputIsAnObject() {
|
||||||
|
val streaming = """
|
||||||
|
{"type":"chat_event","chat_event":{"session_id":"ses_1","message_id":"m1","kind":"tool",
|
||||||
|
"part":{"type":"tool","id":"c1","name":"edit","state":{"status":"streaming","input":"{\"old"}}}}
|
||||||
|
""".trimIndent()
|
||||||
|
val frame = PipelinesJson.decodeFromString(Message.serializer(), streaming).chatEvent!!
|
||||||
|
assertEquals(ChatProtocol.TOOL_STREAMING, frame.part!!.state!!.status)
|
||||||
|
assertEquals("{\"old", (frame.part!!.state!!.input as JsonPrimitive).content)
|
||||||
|
assertTrue(ChatProtocol.toolRunning(frame.part!!.state))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun chatEventDeltaCarriesTheTargetPartAndText() {
|
||||||
|
val json = """
|
||||||
|
{"type":"chat_event","chat_event":{"session_id":"ses_1","message_id":"m1","kind":"text",
|
||||||
|
"delta":"wor","part":{"type":"text","id":"t1"}}}
|
||||||
|
""".trimIndent()
|
||||||
|
val frame = PipelinesJson.decodeFromString(Message.serializer(), json).chatEvent!!
|
||||||
|
assertEquals("ses_1", frame.sessionId)
|
||||||
|
assertEquals("m1", frame.messageId)
|
||||||
|
assertEquals(ChatProtocol.PART_TEXT, frame.kind)
|
||||||
|
assertEquals("wor", frame.delta)
|
||||||
|
assertEquals("t1", frame.part!!.id)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun stepAndUsageFramesDecode() {
|
||||||
|
val step = """
|
||||||
|
{"type":"chat_event","chat_event":{"session_id":"s","kind":"step","step":{"status":"ended","index":3}}}
|
||||||
|
""".trimIndent()
|
||||||
|
val decodedStep = PipelinesJson.decodeFromString(Message.serializer(), step).chatEvent!!
|
||||||
|
assertEquals(ChatProtocol.EVENT_STEP, decodedStep.kind)
|
||||||
|
assertEquals(ChatProtocol.STEP_ENDED, decodedStep.step!!.status)
|
||||||
|
|
||||||
|
val usage = """
|
||||||
|
{"type":"chat_event","chat_event":{"session_id":"s","kind":"usage",
|
||||||
|
"usage":{"input_tokens":12,"output_tokens":34,"cost":0.002}}}
|
||||||
|
""".trimIndent()
|
||||||
|
val decodedUsage = PipelinesJson.decodeFromString(Message.serializer(), usage).chatEvent!!
|
||||||
|
assertEquals(12, decodedUsage.usage!!.inputTokens)
|
||||||
|
assertEquals(34, decodedUsage.usage!!.outputTokens)
|
||||||
|
assertEquals(0.002, decodedUsage.usage!!.cost, 0.0)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun chatPermissionFrameDecodesTheRequestShape() {
|
||||||
|
val json = """
|
||||||
|
{"type":"chat_permission","chat_permission":{"session_id":"ses_1","request_id":"req_9",
|
||||||
|
"action":"edit","resources":["src/a.kt"],
|
||||||
|
"source":{"type":"tool","message_id":"m1","id":"c1"},
|
||||||
|
"message":"Allow this edit?"}}
|
||||||
|
""".trimIndent()
|
||||||
|
val permission = PipelinesJson.decodeFromString(Message.serializer(), json).chatPermission!!
|
||||||
|
assertEquals("req_9", permission.requestId)
|
||||||
|
assertEquals("edit", permission.action)
|
||||||
|
assertEquals("src/a.kt", permission.resources.single())
|
||||||
|
assertEquals("c1", permission.source!!.id)
|
||||||
|
// An open request defaults to unresolved; nothing is invented.
|
||||||
|
assertTrue(!permission.resolved)
|
||||||
|
assertEquals("", permission.decision)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A request the server reports as already settled carries the outcome. */
|
||||||
|
@Test
|
||||||
|
fun chatPermissionFrameCarriesTheServerResolution() {
|
||||||
|
val json = """
|
||||||
|
{"type":"chat_permission","chat_permission":{"session_id":"ses_1","request_id":"req_9",
|
||||||
|
"action":"edit","resolved":true,"decision":"reject","message":"another client rejected it"}}
|
||||||
|
""".trimIndent()
|
||||||
|
val permission = PipelinesJson.decodeFromString(Message.serializer(), json).chatPermission!!
|
||||||
|
assertTrue(permission.resolved)
|
||||||
|
assertEquals(ChatProtocol.DECISION_REJECT, permission.decision)
|
||||||
|
assertEquals("another client rejected it", permission.message)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun chatRequestsRoundTripTheirBodies() {
|
||||||
|
val create = Message(
|
||||||
|
type = Protocol.CHAT_CREATE,
|
||||||
|
id = "android-1",
|
||||||
|
chatCreate = ChatCreateRequest(title = "New chat", directory = "/work"),
|
||||||
|
)
|
||||||
|
val createJson = PipelinesJson.encodeToString(Message.serializer(), create)
|
||||||
|
assertTrue(createJson.contains("\"chat_create\""))
|
||||||
|
val decodedCreate = PipelinesJson.decodeFromString(Message.serializer(), createJson)
|
||||||
|
assertEquals("New chat", decodedCreate.chatCreate!!.title)
|
||||||
|
|
||||||
|
val prompt = Message(
|
||||||
|
type = Protocol.CHAT_PROMPT,
|
||||||
|
id = "android-2",
|
||||||
|
chatPrompt = ChatPromptRequest(sessionId = "ses_1", text = "hi"),
|
||||||
|
)
|
||||||
|
val decodedPrompt = PipelinesJson.decodeFromString(
|
||||||
|
Message.serializer(),
|
||||||
|
PipelinesJson.encodeToString(Message.serializer(), prompt),
|
||||||
|
)
|
||||||
|
assertEquals("ses_1", decodedPrompt.chatPrompt!!.sessionId)
|
||||||
|
assertEquals("hi", decodedPrompt.chatPrompt!!.text)
|
||||||
|
|
||||||
|
val query = Message(type = Protocol.CHAT_MESSAGES, id = "android-3", chatQuery = ChatQuery("ses_1", 50))
|
||||||
|
val decodedQuery = PipelinesJson.decodeFromString(
|
||||||
|
Message.serializer(),
|
||||||
|
PipelinesJson.encodeToString(Message.serializer(), query),
|
||||||
|
)
|
||||||
|
assertEquals("ses_1", decodedQuery.chatQuery!!.sessionId)
|
||||||
|
assertEquals(50, decodedQuery.chatQuery!!.limit)
|
||||||
|
|
||||||
|
val reply = Message(
|
||||||
|
type = Protocol.CHAT_REPLY,
|
||||||
|
id = "android-4",
|
||||||
|
chatReply = ChatReplyRequest("ses_1", "req_9", ChatProtocol.DECISION_ONCE),
|
||||||
|
)
|
||||||
|
val decodedReply = PipelinesJson.decodeFromString(
|
||||||
|
Message.serializer(),
|
||||||
|
PipelinesJson.encodeToString(Message.serializer(), reply),
|
||||||
|
)
|
||||||
|
assertEquals(ChatProtocol.DECISION_ONCE, decodedReply.chatReply!!.decision)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The stop control's interrupt request: pressing it while a turn is in flight
|
||||||
|
* must send a `chat_interrupt` carrying the running session's id and nothing
|
||||||
|
* else, and the frame must survive the wire round-trip the client performs.
|
||||||
|
* Uses the same [ChatProtocol.interruptRequest] builder the repository sends,
|
||||||
|
* so this test cannot drift from the production frame.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
fun chatInterruptRequestCarriesTheRunningSession() {
|
||||||
|
val request = ChatProtocol.interruptRequest("ses_1")
|
||||||
|
assertEquals(Protocol.CHAT_INTERRUPT, request.type)
|
||||||
|
assertEquals("ses_1", request.chatQuery!!.sessionId)
|
||||||
|
|
||||||
|
val encoded = PipelinesJson.encodeToString(Message.serializer(), request.copy(id = "android-9"))
|
||||||
|
val decoded = PipelinesJson.decodeFromString(Message.serializer(), encoded)
|
||||||
|
assertEquals(Protocol.CHAT_INTERRUPT, decoded.type)
|
||||||
|
assertEquals("ses_1", decoded.chatQuery!!.sessionId)
|
||||||
|
assertNull(decoded.chatPrompt)
|
||||||
|
assertNull(decoded.chatReply)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A non-chat envelope leaves every chat field null, so the two never cross-talk. */
|
||||||
|
@Test
|
||||||
|
fun nonChatEnvelopeHasNoChatPayload() {
|
||||||
|
val message = PipelinesJson.decodeFromString(
|
||||||
|
Message.serializer(),
|
||||||
|
"""{"type":"pong"}""",
|
||||||
|
)
|
||||||
|
assertNull(message.chatEvent)
|
||||||
|
assertNull(message.chatSessions)
|
||||||
|
assertNull(message.chatPermission)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun toolDuration(part: ChatPart): Long? {
|
||||||
|
val time = part.time ?: return null
|
||||||
|
return time.completed - time.ran
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,174 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPermissionFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
|
import net.awan.pipelines.data.protocol.Message
|
||||||
|
import net.awan.pipelines.data.protocol.PipelinesJson
|
||||||
|
import net.awan.pipelines.data.protocol.Protocol
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The approval card the conversation shows for a pushed permission request: the
|
||||||
|
* request appears as a card, answering it updates the card in place with the
|
||||||
|
* decision the reply frame carries, and a request the server reports as already
|
||||||
|
* resolved offers no stale actions. Driven through [ChatStore] and the pure
|
||||||
|
* [approvalCard] the composable renders, so no device, server or Compose runtime
|
||||||
|
* is needed.
|
||||||
|
*/
|
||||||
|
class ChatApprovalTest {
|
||||||
|
|
||||||
|
private fun frame(
|
||||||
|
requestId: String = "req_9",
|
||||||
|
action: String = "edit",
|
||||||
|
resources: List<String> = listOf("src/a.kt"),
|
||||||
|
message: String = "This edits a file in your workspace.",
|
||||||
|
resolved: Boolean = false,
|
||||||
|
decision: String = "",
|
||||||
|
) = ChatPermissionFrame(
|
||||||
|
sessionId = "ses_1",
|
||||||
|
requestId = requestId,
|
||||||
|
action = action,
|
||||||
|
resources = resources,
|
||||||
|
message = message,
|
||||||
|
resolved = resolved,
|
||||||
|
decision = decision,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun storeWithPermission(permission: ChatPermissionFrame): ChatStore {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(ChatSession(id = "ses_1", title = "Chat"))
|
||||||
|
store.permission(permission)
|
||||||
|
return store
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun card(store: ChatStore): ApprovalCard {
|
||||||
|
val thread = store.value.thread("ses_1")!!
|
||||||
|
return approvalCard(thread.permission, thread.permissionAnswer)!!
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun permissionFrameShowsAPendingApprovalCard() {
|
||||||
|
val card = card(storeWithPermission(frame()))
|
||||||
|
|
||||||
|
assertEquals(ApprovalState.PENDING, card.state)
|
||||||
|
assertTrue(card.actionable)
|
||||||
|
assertEquals("Approve edit", card.headline)
|
||||||
|
assertEquals("Waiting for your response", card.statusLine)
|
||||||
|
assertEquals(listOf("src/a.kt"), card.resources)
|
||||||
|
assertEquals("This edits a file in your workspace.", card.risk)
|
||||||
|
assertTrue(card.showRisk)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun onceAlwaysAndRejectSendTheRightDecision() {
|
||||||
|
// The same builder the repository sends, so the card's actions and this
|
||||||
|
// assertion cannot drift from the wire frame. Every decision goes through
|
||||||
|
// the identical encode/decode round trip, so none is asserted more weakly
|
||||||
|
// than another.
|
||||||
|
for (decision in listOf(
|
||||||
|
ChatProtocol.DECISION_ONCE,
|
||||||
|
ChatProtocol.DECISION_ALWAYS,
|
||||||
|
ChatProtocol.DECISION_REJECT,
|
||||||
|
)) {
|
||||||
|
val reply = ChatProtocol.replyRequest("ses_1", "req_9", decision)
|
||||||
|
assertEquals(Protocol.CHAT_REPLY, reply.type)
|
||||||
|
assertEquals("ses_1", reply.chatReply!!.sessionId)
|
||||||
|
assertEquals("req_9", reply.chatReply!!.requestId)
|
||||||
|
assertEquals(decision, reply.chatReply!!.decision)
|
||||||
|
|
||||||
|
val decoded = PipelinesJson.decodeFromString(
|
||||||
|
Message.serializer(),
|
||||||
|
PipelinesJson.encodeToString(Message.serializer(), reply.copy(id = "android-1")),
|
||||||
|
)
|
||||||
|
assertEquals(decision, decoded.chatReply!!.decision)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun answeringOnceUpdatesTheCardInPlace() {
|
||||||
|
val store = storeWithPermission(frame())
|
||||||
|
store.answerPermission("ses_1", "req_9", ChatProtocol.DECISION_ONCE)
|
||||||
|
|
||||||
|
val settled = card(store)
|
||||||
|
assertEquals(ApprovalState.ANSWERED, settled.state)
|
||||||
|
assertFalse(settled.actionable)
|
||||||
|
assertEquals(ChatProtocol.DECISION_ONCE, settled.decision)
|
||||||
|
assertEquals("Allowed once", settled.headline)
|
||||||
|
// The request is still on screen, not removed: it just stopped asking.
|
||||||
|
assertEquals("req_9", store.value.thread("ses_1")!!.permission!!.requestId)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun answeringAlwaysUpdatesTheCardInPlace() {
|
||||||
|
val store = storeWithPermission(frame())
|
||||||
|
store.answerPermission("ses_1", "req_9", ChatProtocol.DECISION_ALWAYS)
|
||||||
|
|
||||||
|
val settled = card(store)
|
||||||
|
assertEquals(ApprovalState.ANSWERED, settled.state)
|
||||||
|
assertFalse(settled.actionable)
|
||||||
|
assertEquals(ChatProtocol.DECISION_ALWAYS, settled.decision)
|
||||||
|
assertEquals("Always allowed", settled.headline)
|
||||||
|
// The request stays visible but stops asking; only a denial keeps the
|
||||||
|
// amber review panel, so an allow-always retires it.
|
||||||
|
assertFalse(settled.showRisk)
|
||||||
|
assertEquals("req_9", store.value.thread("ses_1")!!.permission!!.requestId)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun rejectingKeepsTheRiskReviewWhileItSettles() {
|
||||||
|
val store = storeWithPermission(frame())
|
||||||
|
store.answerPermission("ses_1", "req_9", ChatProtocol.DECISION_REJECT)
|
||||||
|
|
||||||
|
val settled = card(store)
|
||||||
|
assertEquals(ApprovalState.ANSWERED, settled.state)
|
||||||
|
assertEquals("Rejected", settled.headline)
|
||||||
|
assertTrue(settled.showRisk)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun serverResolvedRequestOffersNoActions() {
|
||||||
|
val store = storeWithPermission(frame(resolved = true, message = "Another client already answered."))
|
||||||
|
|
||||||
|
val resolved = card(store)
|
||||||
|
assertEquals(ApprovalState.RESOLVED, resolved.state)
|
||||||
|
assertFalse(resolved.actionable)
|
||||||
|
assertEquals("Already resolved", resolved.headline)
|
||||||
|
assertEquals("Another client already answered.", resolved.statusLine)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun serverResolvedDecisionIsNamed() {
|
||||||
|
val store = storeWithPermission(
|
||||||
|
frame(resolved = true, decision = ChatProtocol.DECISION_REJECT, message = ""),
|
||||||
|
)
|
||||||
|
assertEquals("Rejected", card(store).headline)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun failedReplyReopensTheRequest() {
|
||||||
|
val store = storeWithPermission(frame())
|
||||||
|
store.answerPermission("ses_1", "req_9", ChatProtocol.DECISION_ONCE)
|
||||||
|
store.permissionReplyFailed("ses_1", "req_9")
|
||||||
|
assertTrue(card(store).actionable)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun riskFallsBackToTheActionWhenTheServerSendsNoSummary() {
|
||||||
|
val store = storeWithPermission(frame(message = "", resources = emptyList()))
|
||||||
|
val card = card(store)
|
||||||
|
assertTrue(card.risk.contains("edit"))
|
||||||
|
assertEquals(emptyList<String>(), card.resources)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aRequestWithoutAnIdShowsNoCard() {
|
||||||
|
val store = storeWithPermission(frame(requestId = ""))
|
||||||
|
val thread = store.value.thread("ses_1")!!
|
||||||
|
assertNull(approvalCard(thread.permission, thread.permissionAnswer))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,155 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import kotlinx.serialization.json.JsonObject
|
||||||
|
import kotlinx.serialization.json.JsonPrimitive
|
||||||
|
import net.awan.pipelines.data.protocol.ChatError
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPart
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
|
import net.awan.pipelines.data.protocol.ChatTime
|
||||||
|
import net.awan.pipelines.data.protocol.ChatToolContent
|
||||||
|
import net.awan.pipelines.data.protocol.ChatToolState
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
class ChatFormatTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun prettyToolInputPrintsObjectsAndPassesThroughPartialStrings() {
|
||||||
|
val obj = prettyToolInput(JsonObject(mapOf("command" to JsonPrimitive("ls"))))
|
||||||
|
assertTrue(obj.contains("\"command\""))
|
||||||
|
assertTrue(obj.contains("\n"))
|
||||||
|
assertEquals("{\"old", prettyToolInput(JsonPrimitive("{\"old")))
|
||||||
|
assertEquals("", prettyToolInput(null))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolOutputFallsBackToNoOutput() {
|
||||||
|
val completed = ChatToolState(
|
||||||
|
status = ChatProtocol.TOOL_COMPLETED,
|
||||||
|
content = listOf(ChatToolContent(type = "text", text = "hello")),
|
||||||
|
)
|
||||||
|
assertEquals("hello", toolOutputText(completed))
|
||||||
|
assertEquals(
|
||||||
|
"(no output)",
|
||||||
|
toolOutputText(ChatToolState(status = ChatProtocol.TOOL_COMPLETED)),
|
||||||
|
)
|
||||||
|
// Still streaming -> nothing yet, never the "(no output)" claim.
|
||||||
|
assertEquals("", toolOutputText(ChatToolState(status = ChatProtocol.TOOL_RUNNING)))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolErrorPrefersTheMessageOverPartialOutput() {
|
||||||
|
// A failed call can carry both output content and an error; the ERROR
|
||||||
|
// block must show the message, never the output text.
|
||||||
|
val failed = ChatToolState(
|
||||||
|
status = ChatProtocol.TOOL_ERROR,
|
||||||
|
content = listOf(ChatToolContent(type = "text", text = "partial output")),
|
||||||
|
error = ChatError(type = "boom", message = "exploded"),
|
||||||
|
)
|
||||||
|
assertEquals("exploded", toolErrorText(failed))
|
||||||
|
// A failure with no message still renders something rather than a blank block.
|
||||||
|
assertEquals("(no output)", toolErrorText(ChatToolState(status = ChatProtocol.TOOL_ERROR)))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolDurationUsesRanToCompletedAndIsNullWhileRunning() {
|
||||||
|
val done = ChatPart(name = "shell", time = ChatTime(created = 5, ran = 10, completed = 35))
|
||||||
|
assertEquals(25L, toolDurationMillis(done))
|
||||||
|
assertNull(toolDurationMillis(ChatPart(name = "shell", time = ChatTime(created = 5))))
|
||||||
|
assertEquals("340ms", formatToolDuration(340))
|
||||||
|
assertEquals("1.5s", formatToolDuration(1500))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun sessionStatusReportsRunningBusyAndIdle() {
|
||||||
|
assertEquals("Running", sessionStatusLabel(ChatSession(id = "s"), runningLocally = true))
|
||||||
|
assertEquals(
|
||||||
|
"Busy · read-only",
|
||||||
|
sessionStatusLabel(ChatSession(id = "s", busy = true), runningLocally = false),
|
||||||
|
)
|
||||||
|
assertEquals("Idle", sessionStatusLabel(ChatSession(id = "s"), runningLocally = false))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun composerControlIsStopWhileARunIsInFlightAndSendOtherwise() {
|
||||||
|
// While a turn is in flight the send control becomes the stop control:
|
||||||
|
// the phone's composer offers the interrupt, never a second send.
|
||||||
|
assertEquals(ComposerAction.Stop, composerAction(ChatThread(sessionId = "s", running = true)))
|
||||||
|
assertEquals(ComposerAction.Send, composerAction(ChatThread(sessionId = "s")))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolEditDiffMarksOnlyChangedLinesAndCountsThem() {
|
||||||
|
val input = JsonObject(
|
||||||
|
mapOf(
|
||||||
|
"filePath" to JsonPrimitive("/tmp/a.txt"),
|
||||||
|
"oldString" to JsonPrimitive("one\ntwo\nthree"),
|
||||||
|
"newString" to JsonPrimitive("one\nTWO\nthree\nfour"),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
val diff = toolEditDiff(input)!!
|
||||||
|
assertEquals("/tmp/a.txt", diff.file)
|
||||||
|
assertEquals(2, diff.added)
|
||||||
|
assertEquals(1, diff.removed)
|
||||||
|
// A small edit is shown whole, nothing summarised.
|
||||||
|
assertEquals(0, diff.omitted)
|
||||||
|
assertEquals(
|
||||||
|
listOf(
|
||||||
|
DiffLine(DiffKind.CONTEXT, "one"),
|
||||||
|
DiffLine(DiffKind.REMOVE, "two"),
|
||||||
|
DiffLine(DiffKind.ADD, "TWO"),
|
||||||
|
DiffLine(DiffKind.CONTEXT, "three"),
|
||||||
|
DiffLine(DiffKind.ADD, "four"),
|
||||||
|
),
|
||||||
|
diff.lines,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolEditDiffSummarisesAnOversizedEditInsteadOfRenderingEveryLine() {
|
||||||
|
// Wholly disjoint old/new blocks: every line is a change, so the full diff
|
||||||
|
// is twice the block size — far past what a phone should render.
|
||||||
|
val changed = MAX_RENDERED_DIFF_LINES + 50
|
||||||
|
val old = (1..changed).joinToString("\n") { "old $it" }
|
||||||
|
val new = (1..changed).joinToString("\n") { "new $it" }
|
||||||
|
val diff = toolEditDiff(
|
||||||
|
JsonObject(
|
||||||
|
mapOf(
|
||||||
|
"filePath" to JsonPrimitive("/tmp/big.txt"),
|
||||||
|
"oldString" to JsonPrimitive(old),
|
||||||
|
"newString" to JsonPrimitive(new),
|
||||||
|
),
|
||||||
|
),
|
||||||
|
)!!
|
||||||
|
// The stat still describes the whole edit...
|
||||||
|
assertEquals(changed, diff.added)
|
||||||
|
assertEquals(changed, diff.removed)
|
||||||
|
// ...but only a readable prefix is rendered, the rest counted as omitted.
|
||||||
|
assertEquals(MAX_RENDERED_DIFF_LINES, diff.lines.size)
|
||||||
|
assertEquals(2 * changed - MAX_RENDERED_DIFF_LINES, diff.omitted)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolEditDiffIsNullForNonEdits() {
|
||||||
|
assertNull(toolEditDiff(null))
|
||||||
|
assertNull(toolEditDiff(JsonObject(mapOf("command" to JsonPrimitive("ls")))))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun toolFailedOnlyForTheErrorStatus() {
|
||||||
|
assertTrue(toolFailed(ChatToolState(status = ChatProtocol.TOOL_ERROR)))
|
||||||
|
assertFalse(toolFailed(ChatToolState(status = ChatProtocol.TOOL_COMPLETED)))
|
||||||
|
assertFalse(toolFailed(ChatToolState(status = ChatProtocol.TOOL_RUNNING)))
|
||||||
|
assertFalse(toolFailed(null))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun sessionTitleNeverBlank() {
|
||||||
|
assertEquals("Named", sessionTitle(ChatSession(id = "ses_1", title = "Named")))
|
||||||
|
assertEquals("ses_abcdefghijklmn", sessionTitle(ChatSession(id = "ses_abcdefghijklmnop")))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,133 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import net.awan.pipelines.data.protocol.ChatEventFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPart
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
|
import net.awan.pipelines.data.protocol.ChatStep
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The streaming guarantees: a sequence of text deltas grows the rendered
|
||||||
|
* conversation and the running indicator toggles on and off, the elapsed time is
|
||||||
|
* derived from the turn's own start, a reconnect settles the indicator before the
|
||||||
|
* history re-fetch, and a mid-stream failure settles it with the server's text.
|
||||||
|
* Driven directly against [ChatStore] with an injected clock, so no device,
|
||||||
|
* server or Compose runtime is needed.
|
||||||
|
*/
|
||||||
|
class ChatStreamTest {
|
||||||
|
|
||||||
|
private fun session(id: String) = ChatSession(id = id, title = id)
|
||||||
|
|
||||||
|
private fun step(status: String) = ChatEventFrame(
|
||||||
|
sessionId = "s",
|
||||||
|
kind = ChatProtocol.EVENT_STEP,
|
||||||
|
step = ChatStep(status = status),
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun delta(sessionId: String, messageId: String, partId: String, text: String) = ChatEventFrame(
|
||||||
|
sessionId = sessionId,
|
||||||
|
messageId = messageId,
|
||||||
|
kind = ChatProtocol.PART_TEXT,
|
||||||
|
delta = text,
|
||||||
|
part = ChatPart(type = ChatProtocol.PART_TEXT, id = partId),
|
||||||
|
)
|
||||||
|
|
||||||
|
/** The text of the single assistant message, exactly what the transcript renders. */
|
||||||
|
private fun renderedText(store: ChatStore, sessionId: String): String =
|
||||||
|
store.value.thread(sessionId)!!.messages.last().parts.single().text
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun deltaSequenceGrowsRenderedTextAndTogglesRunning() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("s"))
|
||||||
|
store.history("s", emptyList())
|
||||||
|
assertFalse(store.value.thread("s")!!.running)
|
||||||
|
|
||||||
|
// A step starting the turn raises the running indicator.
|
||||||
|
store.event(step(ChatProtocol.STEP_STARTED))
|
||||||
|
assertTrue(store.value.thread("s")!!.running)
|
||||||
|
|
||||||
|
// Each delta appends to the same part: the rendered text is the exact
|
||||||
|
// concatenation and strictly grows, never resets.
|
||||||
|
val chunks = listOf("Hel", "lo ", "wor", "ld")
|
||||||
|
val lengths = mutableListOf<Int>()
|
||||||
|
chunks.forEachIndexed { index, chunk ->
|
||||||
|
store.event(delta("s", "m1", "m1#0", chunk))
|
||||||
|
assertEquals(chunks.take(index + 1).joinToString(""), renderedText(store, "s"))
|
||||||
|
lengths += renderedText(store, "s").length
|
||||||
|
}
|
||||||
|
assertTrue(lengths.zipWithNext().all { (before, after) -> after > before })
|
||||||
|
|
||||||
|
// The step ending the turn lowers the indicator and clears its start.
|
||||||
|
store.event(step(ChatProtocol.STEP_ENDED))
|
||||||
|
assertFalse(store.value.thread("s")!!.running)
|
||||||
|
assertEquals(0L, store.value.thread("s")!!.runningSince)
|
||||||
|
assertEquals("Hello world", renderedText(store, "s"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun elapsedTimeComesFromTheTurnStartAndSurvivesARepeatedStart() {
|
||||||
|
var clock = 1_000L
|
||||||
|
val store = ChatStore(now = { clock })
|
||||||
|
store.open(session("s"))
|
||||||
|
|
||||||
|
store.event(step(ChatProtocol.STEP_STARTED))
|
||||||
|
assertEquals(1_000L, store.value.thread("s")!!.runningSince)
|
||||||
|
|
||||||
|
clock = 6_500L
|
||||||
|
assertEquals(5_500L, store.value.thread("s")!!.elapsedMillis(clock))
|
||||||
|
|
||||||
|
// A second start for the same turn must not move the clock forward.
|
||||||
|
store.event(step(ChatProtocol.STEP_STARTED))
|
||||||
|
assertEquals(1_000L, store.value.thread("s")!!.runningSince)
|
||||||
|
assertEquals(5_500L, store.value.thread("s")!!.elapsedMillis(clock))
|
||||||
|
|
||||||
|
// Settling drops the elapsed to 0 whatever the clock reads.
|
||||||
|
store.event(step(ChatProtocol.STEP_ENDED))
|
||||||
|
assertEquals(0L, store.value.thread("s")!!.elapsedMillis(clock))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun streamResumedSettlesRunningAndReturnsEveryOpenChat() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.history("a", emptyList())
|
||||||
|
store.open(session("b"))
|
||||||
|
store.history("b", emptyList())
|
||||||
|
store.running("a", true)
|
||||||
|
|
||||||
|
// A reconnect names every open chat so the caller re-fetches each, and no
|
||||||
|
// thread keeps claiming to run until a fresh frame proves it.
|
||||||
|
assertEquals(listOf("a", "b"), store.streamResumed())
|
||||||
|
assertFalse(store.value.thread("a")!!.running)
|
||||||
|
|
||||||
|
// A delta after the resync re-asserts the running indicator.
|
||||||
|
store.event(delta("a", "m1", "m1#0", "still going"))
|
||||||
|
assertTrue(store.value.thread("a")!!.running)
|
||||||
|
assertEquals("still going", renderedText(store, "a"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun streamErrorSettlesTheRunningTurnAndKeepsTheServerText() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("s"))
|
||||||
|
store.running("s", true)
|
||||||
|
|
||||||
|
store.streamError("chat stream: boom")
|
||||||
|
val thread = store.value.thread("s")!!
|
||||||
|
assertFalse(thread.running)
|
||||||
|
assertEquals("chat stream: boom", thread.error)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun streamErrorWithNothingRunningIsIgnored() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("s"))
|
||||||
|
store.streamError("chat stream: boom")
|
||||||
|
assertEquals(null, store.value.thread("s")!!.error)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,95 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
class MarkdownTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun fencedCodeKeepsTheLanguageAndBody() {
|
||||||
|
val blocks = parseMarkdown(
|
||||||
|
"""
|
||||||
|
Intro text.
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
val gap = 8.dp
|
||||||
|
println(gap)
|
||||||
|
```
|
||||||
|
""".trimIndent(),
|
||||||
|
)
|
||||||
|
assertEquals(MdParagraph("Intro text."), blocks[0])
|
||||||
|
val code = blocks[1] as MdCodeBlock
|
||||||
|
assertEquals("kotlin", code.language)
|
||||||
|
assertEquals("val gap = 8.dp\nprintln(gap)", code.code)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun anUnterminatedFenceStillYieldsItsCode() {
|
||||||
|
val blocks = parseMarkdown("```\nline one\nline two")
|
||||||
|
val code = blocks.single() as MdCodeBlock
|
||||||
|
assertEquals("", code.language)
|
||||||
|
assertEquals("line one\nline two", code.code)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun softWrappedParagraphLinesJoinWithASpace() {
|
||||||
|
assertEquals(listOf(MdParagraph("one two three")), parseMarkdown("one\ntwo\nthree"))
|
||||||
|
assertEquals(listOf(MdParagraph("one"), MdParagraph("two")), parseMarkdown("one\n\ntwo"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun headingsAndThematicRulesParseByLevel() {
|
||||||
|
val blocks = parseMarkdown("# Title\n\n## Section\n\n---")
|
||||||
|
assertEquals(MdHeading(1, "Title"), blocks[0])
|
||||||
|
assertEquals(MdHeading(2, "Section"), blocks[1])
|
||||||
|
assertEquals(MdRule, blocks[2])
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun bulletAndOrderedListsKeepTheirOrder() {
|
||||||
|
val bullets = parseMarkdown("- one\n- two").single() as MdListBlock
|
||||||
|
assertEquals(false, bullets.ordered)
|
||||||
|
assertEquals(listOf("one", "two"), bullets.items)
|
||||||
|
|
||||||
|
val ordered = parseMarkdown("1. first\n2. second").single() as MdListBlock
|
||||||
|
assertEquals(true, ordered.ordered)
|
||||||
|
assertEquals(listOf("first", "second"), ordered.items)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aPipeTableParsesHeaderAndRows() {
|
||||||
|
val blocks = parseMarkdown("| Name | Value |\n| --- | ---: |\n| a | 1 |\n| b | 2 |")
|
||||||
|
val table = blocks.single() as MdTableBlock
|
||||||
|
assertEquals(listOf("Name", "Value"), table.header)
|
||||||
|
assertEquals(listOf(listOf("a", "1"), listOf("b", "2")), table.rows)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun inlineCodeBoldItalicAndLinksBecomeSpans() {
|
||||||
|
val spans = parseInline("Use `CodeBlock` and **bold** and *italic* and [docs](https://example.com/x).")
|
||||||
|
assertTrue(spans.any { it is MdCodeSpan && it.text == "CodeBlock" })
|
||||||
|
assertTrue(spans.any { it is MdStrong })
|
||||||
|
assertTrue(spans.any { it is MdEmphasis })
|
||||||
|
val link = spans.filterIsInstance<MdLinkSpan>().single()
|
||||||
|
assertEquals("https://example.com/x", link.url)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun bareUrlsAutolinkAndTrimTrailingPunctuation() {
|
||||||
|
val spans = parseInline("See https://example.com/a, then stop.")
|
||||||
|
val link = spans.filterIsInstance<MdLinkSpan>().single()
|
||||||
|
assertEquals("https://example.com/a", link.url)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun underscoresInsideAWordAreNotEmphasis() {
|
||||||
|
assertEquals(listOf(MdPlain("snake_case_name")), parseInline("snake_case_name"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun anEmptySourceParsesToNoBlocks() {
|
||||||
|
assertEquals(emptyList<MdBlock>(), parseMarkdown(""))
|
||||||
|
assertEquals(emptyList<MdBlock>(), parseMarkdown("\n\n"))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,227 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import net.awan.pipelines.data.protocol.ChatEventFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatMessage
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPart
|
||||||
|
import net.awan.pipelines.data.protocol.ChatPermissionFrame
|
||||||
|
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||||
|
import net.awan.pipelines.data.protocol.ChatSession
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNotNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The multi-chat state guarantees: each open chat preserves its own conversation,
|
||||||
|
* a running session re-syncs when the operator returns to it, and the draft and
|
||||||
|
* scroll position are per chat. Driven directly against [ChatStore], with no
|
||||||
|
* device, server or Compose runtime.
|
||||||
|
*/
|
||||||
|
class MultiChatStateTest {
|
||||||
|
|
||||||
|
private fun session(id: String, title: String = id, busy: Boolean = false) =
|
||||||
|
ChatSession(id = id, title = title, busy = busy)
|
||||||
|
|
||||||
|
private fun text(id: String, role: String, body: String) = ChatMessage(
|
||||||
|
id = id,
|
||||||
|
sessionId = "",
|
||||||
|
role = role,
|
||||||
|
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "$id-p", text = body)),
|
||||||
|
)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun switchingPreservesEachConversation() {
|
||||||
|
val store = ChatStore()
|
||||||
|
assertTrue(store.open(session("a", "Chat A")))
|
||||||
|
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "first"), text("a2", ChatProtocol.ROLE_ASSISTANT, "reply A")))
|
||||||
|
|
||||||
|
assertTrue(store.open(session("b", "Chat B")))
|
||||||
|
store.history("b", listOf(text("b1", ChatProtocol.ROLE_USER, "different")))
|
||||||
|
|
||||||
|
// Returning to A shows A's conversation, untouched by B. A loaded,
|
||||||
|
// settled chat needs no re-sync.
|
||||||
|
assertFalse(store.activate("a"))
|
||||||
|
assertEquals(listOf("a1", "a2"), store.value.thread("a")!!.messages.map { it.id })
|
||||||
|
assertEquals("a", store.value.activeId)
|
||||||
|
|
||||||
|
assertFalse(store.activate("b"))
|
||||||
|
assertEquals(listOf("b1"), store.value.thread("b")!!.messages.map { it.id })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun runningSessionResyncsOnReturn() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "prompt")))
|
||||||
|
store.running("a", true)
|
||||||
|
store.open(session("b"))
|
||||||
|
store.history("b", emptyList())
|
||||||
|
|
||||||
|
// Switching to B must not cancel A's running turn.
|
||||||
|
store.activate("b")
|
||||||
|
assertTrue(store.value.thread("a")!!.running)
|
||||||
|
|
||||||
|
// Returning to the running chat reports that it must be re-synced.
|
||||||
|
assertTrue(store.activate("a"))
|
||||||
|
|
||||||
|
// The re-sync replaces the conversation with the server's copy and keeps running.
|
||||||
|
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "prompt"), text("a2", ChatProtocol.ROLE_ASSISTANT, "live")))
|
||||||
|
val resynced = store.value.thread("a")!!
|
||||||
|
assertTrue(resynced.running)
|
||||||
|
assertEquals("live", resynced.messages.last().parts.single().text)
|
||||||
|
// Once it settles, a later return does not force another re-sync.
|
||||||
|
store.running("a", false)
|
||||||
|
store.activate("b")
|
||||||
|
assertFalse(store.activate("a"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun draftsArePerChat() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.open(session("b"))
|
||||||
|
|
||||||
|
store.draft("a", "hello from A")
|
||||||
|
store.draft("b", "typed in B")
|
||||||
|
|
||||||
|
store.activate("a")
|
||||||
|
assertEquals("hello from A", store.value.thread("a")!!.draft)
|
||||||
|
store.activate("b")
|
||||||
|
assertEquals("typed in B", store.value.thread("b")!!.draft)
|
||||||
|
|
||||||
|
// Clearing one chat's draft never touches the other's.
|
||||||
|
store.clearDraft("b")
|
||||||
|
assertEquals("", store.value.thread("b")!!.draft)
|
||||||
|
assertEquals("hello from A", store.value.thread("a")!!.draft)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun scrollPositionIsPerChat() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.open(session("b"))
|
||||||
|
store.scroll("a", 7, 12)
|
||||||
|
store.scroll("b", 1, 0)
|
||||||
|
assertEquals(ChatScrollPosition(7, 12), store.value.thread("a")!!.scroll)
|
||||||
|
assertEquals(ChatScrollPosition(1, 0), store.value.thread("b")!!.scroll)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun busySessionIsReadOnlyAndCannotSend() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a", busy = true))
|
||||||
|
store.draft("a", "unsent")
|
||||||
|
val thread = store.value.thread("a")!!
|
||||||
|
assertTrue(thread.readOnly)
|
||||||
|
assertFalse(thread.canSend)
|
||||||
|
|
||||||
|
// The server can clear busy later; the chat then becomes writable again.
|
||||||
|
store.sessionsLoaded(listOf(session("a", busy = false)))
|
||||||
|
store.draft("a", "unsent")
|
||||||
|
assertFalse(store.value.thread("a")!!.readOnly)
|
||||||
|
assertTrue(store.value.thread("a")!!.canSend)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun sessionsLoadedMergesStatusWithoutDroppingOpenConversations() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a", "Chat A"))
|
||||||
|
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "keep me")))
|
||||||
|
// The server now reports A busy and adds a new session B.
|
||||||
|
store.sessionsLoaded(listOf(session("a", "Chat A renamed", busy = true), session("b", "Chat B")))
|
||||||
|
|
||||||
|
val thread = store.value.thread("a")!!
|
||||||
|
assertEquals("Chat A renamed", thread.title)
|
||||||
|
assertTrue(thread.busy)
|
||||||
|
assertEquals(listOf("a1"), thread.messages.map { it.id })
|
||||||
|
assertEquals(2, store.value.sessions.size)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun backgroundEventsApplyToTheirChatAndCreateAPlaceholder() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "go")))
|
||||||
|
store.open(session("b")) // B is active
|
||||||
|
|
||||||
|
// A delta for the background chat A lands on A, not on B, and B stays active.
|
||||||
|
store.event(
|
||||||
|
ChatEventFrame(
|
||||||
|
sessionId = "a",
|
||||||
|
messageId = "a2",
|
||||||
|
kind = ChatProtocol.PART_TEXT,
|
||||||
|
delta = "streaming",
|
||||||
|
part = ChatPart(type = ChatProtocol.PART_TEXT, id = "a2-p"),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
assertEquals("streaming", store.value.thread("a")!!.messages.last().parts.single().text)
|
||||||
|
assertEquals("b", store.value.activeId)
|
||||||
|
|
||||||
|
// A frame for a chat that was never opened creates a placeholder thread.
|
||||||
|
store.event(
|
||||||
|
ChatEventFrame(
|
||||||
|
sessionId = "c",
|
||||||
|
messageId = "c1",
|
||||||
|
kind = ChatProtocol.PART_TEXT,
|
||||||
|
delta = "hi",
|
||||||
|
part = ChatPart(type = ChatProtocol.PART_TEXT, id = "c1-p"),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
assertNotNull(store.value.thread("c"))
|
||||||
|
assertEquals("hi", store.value.thread("c")!!.messages.single().parts.single().text)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun stepFramesTrackRunningState() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.event(ChatEventFrame(sessionId = "a", kind = ChatProtocol.EVENT_STEP, step = net.awan.pipelines.data.protocol.ChatStep(status = ChatProtocol.STEP_STARTED)))
|
||||||
|
assertTrue(store.value.thread("a")!!.running)
|
||||||
|
store.event(ChatEventFrame(sessionId = "a", kind = ChatProtocol.EVENT_STEP, step = net.awan.pipelines.data.protocol.ChatStep(status = ChatProtocol.STEP_ENDED)))
|
||||||
|
assertFalse(store.value.thread("a")!!.running)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun locallyRunningBusyChatStaysWritable() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a", busy = true))
|
||||||
|
store.running("a", true)
|
||||||
|
// Our own turn keeps the session writable even though the server reports it busy.
|
||||||
|
store.draft("a", "next prompt")
|
||||||
|
val thread = store.value.thread("a")!!
|
||||||
|
assertFalse(thread.readOnly)
|
||||||
|
assertTrue(thread.canSend)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun permissionIsStoredAndAnsweredInPlace() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.permission(ChatPermissionFrame(sessionId = "a", requestId = "r1", action = "edit"))
|
||||||
|
assertEquals("r1", store.value.thread("a")!!.permission!!.requestId)
|
||||||
|
|
||||||
|
store.answerPermission("a", "r1", ChatProtocol.DECISION_ONCE)
|
||||||
|
assertEquals(ChatProtocol.DECISION_ONCE, store.value.thread("a")!!.permissionAnswer)
|
||||||
|
|
||||||
|
// A different request replaces the settled card and drops the old answer.
|
||||||
|
store.permission(ChatPermissionFrame(sessionId = "a", requestId = "r2", action = "bash"))
|
||||||
|
assertEquals("r2", store.value.thread("a")!!.permission!!.requestId)
|
||||||
|
assertEquals("", store.value.thread("a")!!.permissionAnswer)
|
||||||
|
|
||||||
|
// A failed reply reopens the request it answers.
|
||||||
|
store.answerPermission("a", "r2", ChatProtocol.DECISION_REJECT)
|
||||||
|
store.permissionReplyFailed("a", "r2")
|
||||||
|
assertEquals("", store.value.thread("a")!!.permissionAnswer)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun closeRemovesOnlyThatChat() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(session("a"))
|
||||||
|
store.open(session("b"))
|
||||||
|
store.close("a")
|
||||||
|
assertFalse(store.value.open.any { it.sessionId == "a" })
|
||||||
|
assertTrue(store.value.open.any { it.sessionId == "b" })
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,42 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import androidx.compose.ui.unit.IntOffset
|
||||||
|
import androidx.compose.ui.unit.IntRect
|
||||||
|
import androidx.compose.ui.unit.IntSize
|
||||||
|
import androidx.compose.ui.unit.LayoutDirection
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The tool panel's placement: below the chip when it fits, flipped above when it
|
||||||
|
* does not, and always kept inside the window margins. Driven directly against
|
||||||
|
* the provider, so it needs no device or Compose runtime.
|
||||||
|
*/
|
||||||
|
class ToolPanelPositionProviderTest {
|
||||||
|
|
||||||
|
private val provider = ToolPanelPositionProvider(gapPx = 4, marginPx = 8)
|
||||||
|
private val window = IntSize(width = 1000, height = 2000)
|
||||||
|
|
||||||
|
private fun place(anchor: IntRect, content: IntSize): IntOffset =
|
||||||
|
provider.calculatePosition(anchor, window, LayoutDirection.Ltr, content)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun placesBelowTheChipWhenItFits() {
|
||||||
|
val anchor = IntRect(left = 40, top = 100, right = 340, bottom = 160)
|
||||||
|
assertEquals(IntOffset(40, 164), place(anchor, IntSize(400, 500)))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun flipsAboveWhenThereIsNoRoomBelow() {
|
||||||
|
val anchor = IntRect(left = 40, top = 1800, right = 340, bottom = 1860)
|
||||||
|
// 1860 + 4 + 500 > 2000 - 8, so it goes above: 1800 - 500 - 4 = 1296.
|
||||||
|
assertEquals(IntOffset(40, 1296), place(anchor, IntSize(400, 500)))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun clampsToTheRightAndTopMargins() {
|
||||||
|
val anchor = IntRect(left = 950, top = 20, right = 990, bottom = 60)
|
||||||
|
// Width 400 cannot start at 950; it is pulled in to the right margin.
|
||||||
|
assertEquals(IntOffset(592, 64), place(anchor, IntSize(400, 500)))
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user