41a9e99da8
On a wide split window a run's stage page (or an artifact, a file) opens inside the detail pane's own navigator. Selecting another run kept that page on top, so the pane still showed the old stage. ListDetailPanes now takes the selected item's identity (run, chat or pipeline id) and the pane navigator pops back to the item when it changes.
274 lines
9.4 KiB
Dart
274 lines
9.4 KiB
Dart
import '../../shell/destination.dart';
|
|
import '../../shell/detail_page.dart';
|
|
import '../../shell/empty_detail_pane.dart';
|
|
import '../../shell/list_detail.dart';
|
|
import 'dart:async';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../core/api_gateway.dart';
|
|
import 'conversation/chat_models.dart';
|
|
import 'conversation/chat_scroll.dart';
|
|
import 'conversation/chat_thread_view.dart';
|
|
import 'conversation/chat_transcript_cache.dart';
|
|
import 'data/chat_repository.dart';
|
|
import 'ui/sessions/chat_sessions_controller.dart';
|
|
import 'ui/sessions/chat_sessions_screen.dart';
|
|
|
|
/// The Chat destination's list/detail switch.
|
|
///
|
|
/// The route names the open session, so a row tap, a deep link and Back all
|
|
/// navigate through the same value. The session list stays mounted (offstage)
|
|
/// while a conversation is open, so returning to it keeps its rows and query.
|
|
/// The destination owns the list controller too, so a session a conversation's
|
|
/// `/new` creates is listed, opened and refreshed from here.
|
|
/// The shell owns the app bar; this screen adds no second one.
|
|
class ChatScreen extends StatefulWidget {
|
|
const ChatScreen({
|
|
super.key,
|
|
required this.gateway,
|
|
this.initialSessionId,
|
|
this.syncToken = 0,
|
|
this.onSessionSelected,
|
|
this.onBack,
|
|
});
|
|
|
|
final ApiGateway gateway;
|
|
|
|
/// The chat session the current route names, or null for the list.
|
|
final String? initialSessionId;
|
|
|
|
/// Advances when the shared socket is replaced. The open conversation
|
|
/// re-subscribes and re-reads in place, so its selection survives.
|
|
final int syncToken;
|
|
|
|
final ValueChanged<String>? onSessionSelected;
|
|
final VoidCallback? onBack;
|
|
|
|
@override
|
|
State<ChatScreen> createState() => _ChatScreenState();
|
|
}
|
|
|
|
class _ChatScreenState extends State<ChatScreen> {
|
|
/// The list's controller, shared with the mounted list screen. The list
|
|
/// screen refreshes it on mount and swaps its repository when the socket is
|
|
/// replaced; this destination lists created rows and re-reads after a
|
|
/// conversation's command changes a session.
|
|
late final ChatSessionsController _sessions = ChatSessionsController(
|
|
ChatRepository(widget.gateway),
|
|
);
|
|
|
|
/// Rows this visit has opened, used for the native title and the recorded
|
|
/// model facts. The mounted list also reports its loaded rows, so a routed id
|
|
/// (a deep link) resolves the same row without a second list request.
|
|
final Map<String, JsonMap> _openedSessions = {};
|
|
|
|
/// Model switches the server accepted after a row was opened. The row that
|
|
/// opened the conversation may still carry the pre-switch model, so these win
|
|
/// for the rest of this visit, including when the same chat is reopened.
|
|
final Map<String, ChatModelSelection> _acceptedModels = {};
|
|
|
|
/// Transcript positions for this visit. It lives with the destination, not a
|
|
/// conversation view, so Back and a reopened chat return to the same place.
|
|
final ChatScrollStore _scrollPositions = MemoryChatScrollStore();
|
|
|
|
/// Transcripts of recently left chats for this visit, so a reopened chat
|
|
/// shows its last transcript at once while it re-subscribes and re-reads.
|
|
/// Bounded and in memory only; see [ChatTranscriptCache].
|
|
final ChatTranscriptCache _transcripts = ChatTranscriptCache();
|
|
|
|
/// The line a just-created conversation opens on, tied to the selection
|
|
/// `/new` made. Leaving that conversation drops it, so a later reopen is an
|
|
/// ordinary visit.
|
|
({String id, String notice})? _startNotice;
|
|
|
|
String? _standaloneSelection;
|
|
|
|
String? get _selected {
|
|
final routed = widget.initialSessionId;
|
|
if (routed != null && routed.isNotEmpty) return routed;
|
|
return _standaloneSelection;
|
|
}
|
|
|
|
void _open(JsonMap session) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
_openedSessions[id] = session;
|
|
if (_startNotice?.id != id) _startNotice = null;
|
|
final select = widget.onSessionSelected;
|
|
if (select != null) {
|
|
select(id);
|
|
} else {
|
|
setState(() => _standaloneSelection = id);
|
|
}
|
|
}
|
|
|
|
/// `/new` created [session]: list it at the head before its conversation
|
|
/// opens, open it on [notice], then re-read the list from the server.
|
|
void _openCreated(JsonMap session, String notice) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
_sessions.insertCreated(session);
|
|
_startNotice = (id: id, notice: notice);
|
|
_open(session);
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// `/rename` was accepted for [id]: the opened row follows the shared title
|
|
/// and the list re-reads it.
|
|
void _renamed(String id, String title) {
|
|
final row = _openedSessions[id];
|
|
if (row != null) {
|
|
setState(() => _openedSessions[id] = {...row, 'title': title});
|
|
}
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// `/close` was accepted: the conversation leaves, back to the list, which
|
|
/// re-reads the closed row.
|
|
void _closed() {
|
|
_back();
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// Adopts the list's loaded rows for the routed session: a deep link opens
|
|
/// the conversation before any row has been tapped, and the header's title
|
|
/// and model control come from that row. Called after a frame, never during
|
|
/// the list's own build.
|
|
void _adoptRows(List<JsonMap> rows) {
|
|
final id = _selected;
|
|
if (id == null || _openedSessions.containsKey(id)) return;
|
|
for (final row in rows) {
|
|
if ('${row['id'] ?? ''}' != id) continue;
|
|
setState(() => _openedSessions[id] = row);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void _modelChanged(String id, ChatModelSelection applied) {
|
|
if (!mounted) return;
|
|
setState(() => _acceptedModels[id] = applied);
|
|
}
|
|
|
|
/// An accepted mode switch updates the opened row, so reopening the chat in
|
|
/// this visit shows it before the list re-reads.
|
|
void _modeChanged(String id, String mode, String name) {
|
|
final row = _openedSessions[id];
|
|
if (!mounted || row == null) return;
|
|
setState(
|
|
() => _openedSessions[id] = {...row, 'mode': mode, 'mode_name': name},
|
|
);
|
|
}
|
|
|
|
/// The row to open for [id], with an accepted model folded in.
|
|
JsonMap? _rowFor(String id) {
|
|
final row = _openedSessions[id];
|
|
final accepted = _acceptedModels[id];
|
|
if (row == null || accepted == null) return row;
|
|
return {
|
|
...row,
|
|
'model': accepted.model,
|
|
'model_provider': accepted.provider,
|
|
'model_selection': accepted.selection,
|
|
};
|
|
}
|
|
|
|
void _back() {
|
|
_startNotice = null;
|
|
final back = widget.onBack;
|
|
if (back != null) {
|
|
back();
|
|
} else {
|
|
setState(() => _standaloneSelection = null);
|
|
}
|
|
}
|
|
|
|
/// On a phone the open chat is a real page above the main screen.
|
|
final DetailPageHost _page = DetailPageHost();
|
|
|
|
@override
|
|
void didUpdateWidget(covariant ChatScreen oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
// Transcripts read through another gateway belong to that server.
|
|
if (oldWidget.gateway != widget.gateway) _transcripts.clear();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_page.dispose();
|
|
_sessions.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
Widget _thread(String selected, VoidCallback onBack) {
|
|
final row = _rowFor(selected);
|
|
final start = _startNotice;
|
|
return ChatThreadView(
|
|
key: ValueKey<String>('chat-session-$selected'),
|
|
gateway: widget.gateway,
|
|
sessionId: selected,
|
|
title: '${row?['title'] ?? ''}'.trim(),
|
|
session: row,
|
|
syncToken: widget.syncToken,
|
|
scrollPositions: _scrollPositions,
|
|
transcripts: _transcripts,
|
|
initialNotice: start != null && start.id == selected
|
|
? start.notice
|
|
: null,
|
|
onBack: onBack,
|
|
onModelChanged: (applied) => _modelChanged(selected, applied),
|
|
onModeChanged: (mode, name) => _modeChanged(selected, mode, name),
|
|
onCreatedSession: _openCreated,
|
|
onSessionRenamed: (title) => _renamed(selected, title),
|
|
onSessionClosed: _closed,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final selected = _selected;
|
|
// A phone opens a chat as a real Navigator page with stock Back. A wide
|
|
// window keeps the destination rail and the chat list beside the open
|
|
// chat, which has no Back: another row, `/close` or a route change swaps it.
|
|
final beside = showsListBesideDetail(context);
|
|
_page.sync(
|
|
context,
|
|
selected: selected != null && !beside,
|
|
destination: AppDestination.chat,
|
|
onClosed: _back,
|
|
builder: (context) => selected == null
|
|
? const SizedBox.shrink()
|
|
: _thread(selected, () => Navigator.of(context).maybePop()),
|
|
);
|
|
// The session list pads its first row by the bar's height itself, so it
|
|
// scrolls behind the shell's floating bar like the other lists.
|
|
final list = ChatSessionsScreen(
|
|
gateway: widget.gateway,
|
|
embedded: true,
|
|
syncToken: widget.syncToken,
|
|
controller: _sessions,
|
|
onOpen: _open,
|
|
onSessions: _adoptRows,
|
|
activeSessionId: selected,
|
|
publishShellBar: true,
|
|
);
|
|
if (!beside) return list;
|
|
return ListDetailPanes(
|
|
list: list,
|
|
detailIdentity: selected,
|
|
detail: selected == null
|
|
? const EmptyDetailPane(
|
|
destination: AppDestination.chat,
|
|
message: 'Select a chat to open it here.',
|
|
)
|
|
: DetailPane(
|
|
key: const ValueKey('chat-detail-pane'),
|
|
destination: AppDestination.chat,
|
|
implyBack: false,
|
|
builder: (context) => _thread(selected, _back),
|
|
),
|
|
);
|
|
}
|
|
}
|