git.iko.soy/opencode-android
on 3e94016 help sign in
opencode-android/shared/src/app.rs
1028 lines 39 kB history raw
1//! The Crux `App`: model, events, effects, update logic and view.
2//!
3//! Streaming works like this: after a successful connect the shell opens the
4//! `/event` SSE stream and forwards every decoded event as
5//! [`Event::ServerEvent`]. The core parses those and mutates the chat
6//! incrementally — creating the assistant message on `message.updated`, growing
7//! its text on `message.part.updated`, and clearing the "generating" flag on
8//! `session.idle`. User messages are shown optimistically the moment they're
9//! sent, so the stream only ever *adds* assistant content.
11use base64::Engine;
12use crux_core::{
13 macros::effect,
14 render::{render, RenderOperation},
15 App, Command,
16};
17use crux_http::command::{Http, RequestBuilder};
18use crux_http::protocol::HttpRequest;
19use serde::{Deserialize, Serialize};
21use crate::protocol::{self, ServerEvent, WireMessageEnvelope, WirePart};
23/// Result of an HTTP effect handed back to the core.
24pub type HttpResult = Result<crux_http::Response<String>, crux_http::HttpError>;
26// ─── Events ──────────────────────────────────────────────────────────────────
28pub enum Event {
29 // Lifecycle / connect
30 Start,
31 ServerUrlChanged(String),
32 UsernameChanged(String),
33 PasswordChanged(String),
34 Connect,
36 // Sessions
37 LoadSessions,
38 SelectSession(String),
39 CreateSession,
40 DeleteSession(String),
42 // Chat
43 LoadMessages(String),
44 DraftChanged(String),
45 SendMessage(String),
46 CancelGeneration,
48 // A raw event line from the shell's `/event` SSE subscription.
49 ServerEvent(String),
51 // Navigation / misc
52 NavigateToSessions,
53 NavigateToConnect,
54 DismissError,
56 // ── Internal: results of HTTP effects (never sent by the shell) ──────────
57 HealthProbed(HttpResult),
58 SessionsLoaded(HttpResult),
59 SessionCreated(HttpResult),
60 MessagesLoaded(String, HttpResult),
61 PromptSent(HttpResult),
62 SessionDeleted(HttpResult),
63 Aborted(HttpResult),
66// ─── Effects ─────────────────────────────────────────────────────────────────
68#[effect]
69#[derive(Debug)]
70pub enum Effect {
71 Render(RenderOperation),
72 Http(HttpRequest),
75// ─── Model ───────────────────────────────────────────────────────────────────
77#[derive(Default)]
78pub struct Model {
79 server_url: String,
80 username: String,
81 password: String,
82 /// The server answered 401 to an unauthenticated probe — show credentials.
83 auth_required: bool,
84 /// Credentials were accepted; attach the auth header to every request.
85 authed: bool,
86 connected: bool,
87 loading: bool,
88 error: Option<String>,
89 screen: Screen,
91 sessions: Vec<SessionView>,
92 current_session_id: Option<String>,
93 current_session_title: String,
95 messages: Vec<MsgState>,
96 draft: String,
97 generating: bool,
99 /// Monotonic counter for optimistic (client-side) user-message ids.
100 local_seq: u64,
103impl Model {
104 fn message_mut(&mut self, id: &str) -> Option<&mut MsgState> {
105 self.messages.iter_mut().find(|m| m.id == id)
106 }
108 fn has_credentials(&self) -> bool {
109 !self.username.is_empty() || !self.password.is_empty()
110 }
112 fn is_current(&self, session_id: &str) -> bool {
113 self.current_session_id.as_deref() == Some(session_id)
114 }
117/// Internal per-message state. Parts are tracked by id so streaming updates can
118/// upsert them; the [`MessageView`] handed to the shell is derived from these.
119struct MsgState {
120 id: String,
121 role: String,
122 time: u64,
123 status: MessageStatus,
124 streaming: bool,
125 text_parts: Vec<(String, String)>,
126 reasoning_parts: Vec<(String, String)>,
127 tool_parts: Vec<(String, ToolView)>,
130impl MsgState {
131 fn new(id: String, role: String, time: u64) -> Self {
132 Self {
133 id,
134 role,
135 time,
136 status: MessageStatus::Sent,
137 streaming: false,
138 text_parts: Vec::new(),
139 reasoning_parts: Vec::new(),
140 tool_parts: Vec::new(),
141 }
142 }
144 fn upsert_part(parts: &mut Vec<(String, String)>, id: &str, text: String) {
145 if let Some(slot) = parts.iter_mut().find(|(pid, _)| pid == id) {
146 slot.1 = text;
147 } else {
148 parts.push((id.to_string(), text));
149 }
150 }
152 fn upsert_tool(&mut self, id: &str, view: ToolView) {
153 if let Some(slot) = self.tool_parts.iter_mut().find(|(pid, _)| pid == id) {
154 slot.1 = view;
155 } else {
156 self.tool_parts.push((id.to_string(), view));
157 }
158 }
160 fn remove_part(&mut self, part_id: &str) {
161 self.text_parts.retain(|(pid, _)| pid != part_id);
162 self.reasoning_parts.retain(|(pid, _)| pid != part_id);
163 self.tool_parts.retain(|(pid, _)| pid != part_id);
164 }
166 fn to_view(&self) -> MessageView {
167 let join = |parts: &[(String, String)]| {
168 parts.iter().map(|(_, t)| t.as_str()).collect::<String>()
169 };
170 let reasoning = join(&self.reasoning_parts);
171 MessageView {
172 id: self.id.clone(),
173 role: self.role.clone(),
174 text: join(&self.text_parts),
175 reasoning: (!reasoning.is_empty()).then_some(reasoning),
176 tools: self.tool_parts.iter().map(|(_, t)| t.clone()).collect(),
177 time: self.time,
178 status: self.status.clone(),
179 streaming: self.streaming,
180 }
181 }
184// ─── View model ──────────────────────────────────────────────────────────────
186#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
187pub enum Screen {
188 #[default]
189 Connect,
190 Sessions,
191 Chat,
194#[derive(Serialize, Deserialize, Clone, Debug, Default)]
195pub struct SessionView {
196 pub id: String,
197 pub title: String,
200#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
201pub enum MessageStatus {
202 #[default]
203 Sent,
204 Pending,
205 Failed,
208#[derive(Serialize, Deserialize, Clone, Debug, Default)]
209pub struct ToolView {
210 pub name: String,
211 pub status: String,
212 pub title: Option<String>,
215#[derive(Serialize, Deserialize, Clone, Debug, Default)]
216pub struct MessageView {
217 pub id: String,
218 pub role: String,
219 pub text: String,
220 pub reasoning: Option<String>,
221 pub tools: Vec<ToolView>,
222 pub time: u64,
223 pub status: MessageStatus,
224 pub streaming: bool,
227#[derive(Serialize, Deserialize, Clone, Debug, Default)]
228pub struct ViewModel {
229 pub screen: Screen,
230 pub server_url: String,
231 pub username: String,
232 pub password: String,
233 pub auth_required: bool,
234 pub connected: bool,
235 pub loading: bool,
236 pub error: Option<String>,
237 pub sessions: Vec<SessionView>,
238 pub current_session_id: Option<String>,
239 pub current_session_title: String,
240 pub messages: Vec<MessageView>,
241 pub draft: String,
242 pub generating: bool,
245// ─── App ─────────────────────────────────────────────────────────────────────
247#[derive(Default)]
248pub struct OpencodeApp;
250impl OpencodeApp {
251 fn get(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
252 let url = format!("{}{path}", model.server_url);
253 self.with_auth(Http::get(&url).expect_string(), model)
254 }
256 fn post_json(&self, model: &Model, path: &str, body: &serde_json::Value) -> RequestBuilder<Effect, Event, String> {
257 let url = format!("{}{path}", model.server_url);
258 let bytes = serde_json::to_vec(body).unwrap_or_default();
259 let req = Http::post(&url)
260 .expect_string()
261 .header("Content-Type", "application/json")
262 .body_bytes(bytes);
263 self.with_auth(req, model)
264 }
266 fn delete(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
267 let url = format!("{}{path}", model.server_url);
268 self.with_auth(Http::delete(&url).expect_string(), model)
269 }
271 /// Attach an RFC 7617 Basic-Auth header when the model carries credentials.
272 fn with_auth<E>(&self, req: RequestBuilder<Effect, Event, E>, model: &Model) -> RequestBuilder<Effect, Event, E>
273 where
274 E: 'static,
275 {
276 if model.has_credentials() {
277 let creds = format!("{}:{}", model.username, model.password);
278 let encoded = base64::engine::general_purpose::STANDARD.encode(creds.as_bytes());
279 req.header("Authorization", format!("Basic {encoded}"))
280 } else {
281 req
282 }
283 }
286impl App for OpencodeApp {
287 type Event = Event;
288 type Model = Model;
289 type ViewModel = ViewModel;
290 type Effect = Effect;
292 fn update(&self, event: Event, model: &mut Model) -> Command<Effect, Event> {
293 match event {
294 // ── Lifecycle / connect ─────────────────────────────────────────
295 Event::Start => render(),
297 Event::ServerUrlChanged(url) => {
298 model.server_url = normalize_url(&url);
299 render()
300 }
301 Event::UsernameChanged(u) => {
302 model.username = u;
303 render()
304 }
305 Event::PasswordChanged(p) => {
306 model.password = p;
307 render()
308 }
310 Event::Connect => {
311 if model.server_url.is_empty() {
312 model.error = Some("Enter a server URL".to_string());
313 return render();
314 }
315 model.loading = true;
316 model.error = None;
317 model.auth_required = false;
318 render().and(self.get(model, "/global/health").build().then_send(Event::HealthProbed))
319 }
321 Event::HealthProbed(result) => self.on_health_probed(model, result),
323 // ── Sessions ────────────────────────────────────────────────────
324 Event::LoadSessions => {
325 model.loading = true;
326 render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded))
327 }
329 Event::SessionsLoaded(result) => {
330 model.loading = false;
331 match ok_body(result) {
332 Ok(body) => {
333 model.sessions = protocol::parse_sessions(&body)
334 .into_iter()
335 .map(|s| SessionView {
336 id: s.id,
337 title: display_title(&s.title),
338 })
339 .collect();
340 }
341 Err(e) => model.error = Some(e),
342 }
343 render()
344 }
346 Event::SelectSession(id) => {
347 model.current_session_title = model
348 .sessions
349 .iter()
350 .find(|s| s.id == id)
351 .map(|s| s.title.clone())
352 .unwrap_or_default();
353 model.current_session_id = Some(id.clone());
354 model.messages.clear();
355 model.screen = Screen::Chat;
356 model.loading = true;
357 model.error = None;
358 render().and(Command::event(Event::LoadMessages(id)))
359 }
361 Event::CreateSession => {
362 model.loading = true;
363 render().and(
364 self.post_json(model, "/session", &serde_json::json!({}))
365 .build()
366 .then_send(Event::SessionCreated),
367 )
368 }
370 Event::SessionCreated(result) => {
371 model.loading = false;
372 match ok_body(result) {
373 Ok(body) => {
374 if let Some(s) = protocol::parse_session(&body) {
375 let view = SessionView {
376 id: s.id.clone(),
377 title: display_title(&s.title),
378 };
379 if !model.sessions.iter().any(|e| e.id == view.id) {
380 model.sessions.insert(0, view);
381 }
382 return render().and(Command::event(Event::SelectSession(s.id)));
383 }
384 model.error = Some("Malformed session response".to_string());
385 }
386 Err(e) => model.error = Some(e),
387 }
388 render()
389 }
391 Event::DeleteSession(id) => {
392 model.sessions.retain(|s| s.id != id);
393 let mut cmd = self.delete(model, &format!("/session/{id}")).build().then_send(Event::SessionDeleted);
394 if model.is_current(&id) {
395 model.current_session_id = None;
396 model.messages.clear();
397 model.screen = Screen::Sessions;
398 }
399 cmd = render().and(cmd);
400 cmd
401 }
403 Event::SessionDeleted(result) => {
404 if let Err(e) = ok_body(result) {
405 model.error = Some(e);
406 }
407 render()
408 }
410 // ── Chat ────────────────────────────────────────────────────────
411 Event::LoadMessages(id) => {
412 render().and(
413 self.get(model, &format!("/session/{id}/message"))
414 .build()
415 .then_send(move |result| Event::MessagesLoaded(id.clone(), result)),
416 )
417 }
419 Event::MessagesLoaded(session_id, result) => {
420 if !model.is_current(&session_id) {
421 return render();
422 }
423 model.loading = false;
424 match ok_body(result) {
425 Ok(body) => {
426 model.messages = protocol::parse_messages(&body).iter().map(message_from_wire).collect();
427 model.generating = model.messages.iter().any(|m| m.streaming);
428 }
429 Err(e) => model.error = Some(e),
430 }
431 render()
432 }
434 Event::DraftChanged(text) => {
435 model.draft = text;
436 render()
437 }
439 Event::SendMessage(text) => {
440 let text = text.trim().to_string();
441 let Some(session_id) = model.current_session_id.clone() else {
442 return render();
443 };
444 if text.is_empty() {
445 return render();
446 }
447 model.local_seq += 1;
448 let mut user = MsgState::new(format!("local-{}", model.local_seq), "user".to_string(), 0);
449 user.status = MessageStatus::Pending;
450 MsgState::upsert_part(&mut user.text_parts, "local", text.clone());
451 model.messages.push(user);
452 model.draft.clear();
453 model.generating = true;
454 model.error = None;
456 let body = serde_json::json!({ "parts": [{ "type": "text", "text": text }] });
457 render().and(
458 self.post_json(model, &format!("/session/{session_id}/prompt_async"), &body)
459 .build()
460 .then_send(Event::PromptSent),
461 )
462 }
464 Event::PromptSent(result) => {
465 match ok_body(result) {
466 Ok(_) => set_last_pending(model, MessageStatus::Sent),
467 Err(e) => {
468 set_last_pending(model, MessageStatus::Failed);
469 model.generating = false;
470 model.error = Some(e);
471 }
472 }
473 render()
474 }
476 Event::CancelGeneration => {
477 model.generating = false;
478 match model.current_session_id.clone() {
479 Some(id) => render().and(
480 self.post_json(model, &format!("/session/{id}/abort"), &serde_json::json!({}))
481 .build()
482 .then_send(Event::Aborted),
483 ),
484 None => render(),
485 }
486 }
488 Event::Aborted(_) => render(),
490 // ── SSE ─────────────────────────────────────────────────────────
491 Event::ServerEvent(json) => {
492 if let Some(event) = protocol::parse_event(&json) {
493 apply_server_event(model, event);
494 }
495 render()
496 }
498 // ── Navigation / misc ───────────────────────────────────────────
499 Event::NavigateToSessions => {
500 model.screen = Screen::Sessions;
501 model.current_session_id = None;
502 model.messages.clear();
503 model.generating = false;
504 render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded))
505 }
507 Event::NavigateToConnect => {
508 model.screen = Screen::Connect;
509 model.connected = false;
510 model.sessions.clear();
511 model.messages.clear();
512 model.current_session_id = None;
513 render()
514 }
516 Event::DismissError => {
517 model.error = None;
518 render()
519 }
520 }
521 }
523 fn view(&self, model: &Model) -> ViewModel {
524 ViewModel {
525 screen: model.screen.clone(),
526 server_url: model.server_url.clone(),
527 username: model.username.clone(),
528 password: model.password.clone(),
529 auth_required: model.auth_required,
530 connected: model.connected,
531 loading: model.loading,
532 error: model.error.clone(),
533 sessions: model.sessions.clone(),
534 current_session_id: model.current_session_id.clone(),
535 current_session_title: model.current_session_title.clone(),
536 messages: model.messages.iter().map(MsgState::to_view).collect(),
537 draft: model.draft.clone(),
538 generating: model.generating,
539 }
540 }
543impl OpencodeApp {
544 fn on_health_probed(&self, model: &mut Model, result: HttpResult) -> Command<Effect, Event> {
545 let has_creds = model.has_credentials();
546 match result {
547 Ok(response) => {
548 let status = response.status().as_u16();
549 if status == 401 {
550 model.loading = false;
551 if has_creds {
552 model.error = Some("Invalid credentials".to_string());
553 } else {
554 model.auth_required = true;
555 }
556 return render();
557 }
558 if (200..300).contains(&status) {
559 if has_creds {
560 model.authed = true;
561 }
562 model.connected = true;
563 model.auth_required = false;
564 model.error = None;
565 model.screen = Screen::Sessions;
566 model.loading = true;
567 return render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded));
568 }
569 model.loading = false;
570 model.error = Some(format!("Server returned status {status}"));
571 render()
572 }
573 Err(e) => {
574 model.loading = false;
575 model.error = Some(format!("Connection failed: {e}"));
576 render()
577 }
578 }
579 }
582// ─── SSE application ─────────────────────────────────────────────────────────
584fn apply_server_event(model: &mut Model, event: ServerEvent) {
585 match event {
586 // Only assistant messages are created from the stream — the user's own
587 // message is already shown optimistically, so ignoring the server's copy
588 // avoids a duplicate bubble.
589 ServerEvent::MessageUpdated { properties } => {
590 let info = properties.info;
591 if info.role != "assistant" || !model.is_current(&info.session_id) {
592 return;
593 }
594 let streaming = info.time.completed.is_none() && info.error.is_none();
595 if let Some(msg) = model.message_mut(&info.id) {
596 msg.streaming = streaming;
597 if msg.time == 0 {
598 msg.time = info.time.created;
599 }
600 } else {
601 let mut msg = MsgState::new(info.id.clone(), "assistant".to_string(), info.time.created);
602 msg.streaming = streaming;
603 model.messages.push(msg);
604 }
605 if let Some(err) = info.error {
606 model.error = Some(err.message());
607 model.generating = false;
608 }
609 }
611 // Apply only to a message we already track (an assistant message from the
612 // event above). Parts for unknown ids are ignored — see module docs.
613 ServerEvent::MessagePartUpdated { properties } => {
614 let part = properties.part;
615 let delta = properties.delta;
616 let msg_id = part.message_id().to_string();
617 let Some(msg) = model.message_mut(&msg_id) else {
618 return;
619 };
620 match part {
621 WirePart::Text { id, text, synthetic, .. } => {
622 if synthetic {
623 return;
624 }
625 let value = pick_text(text, &delta, &msg.text_parts, &id);
626 MsgState::upsert_part(&mut msg.text_parts, &id, value);
627 }
628 WirePart::Reasoning { id, text, .. } => {
629 let value = pick_text(text, &delta, &msg.reasoning_parts, &id);
630 MsgState::upsert_part(&mut msg.reasoning_parts, &id, value);
631 }
632 WirePart::Tool { id, tool, state, .. } => {
633 let sv = protocol::tool_state_view(&state);
634 msg.upsert_tool(&id, ToolView { name: tool, status: sv.status, title: sv.title });
635 }
636 WirePart::Other => {}
637 }
638 }
640 ServerEvent::MessagePartRemoved { properties } => {
641 if let Some(msg) = model.message_mut(&properties.message_id) {
642 msg.remove_part(&properties.part_id);
643 }
644 }
646 ServerEvent::MessageRemoved { properties } => {
647 model.messages.retain(|m| m.id != properties.message_id);
648 }
650 ServerEvent::SessionIdle { properties } => {
651 if model.is_current(&properties.session_id) {
652 model.generating = false;
653 for m in &mut model.messages {
654 m.streaming = false;
655 }
656 }
657 }
659 ServerEvent::SessionError { properties } => {
660 let scoped = properties.session_id.as_deref().map_or(true, |s| model.is_current(s));
661 if scoped {
662 if let Some(err) = properties.error {
663 model.error = Some(err.message());
664 }
665 model.generating = false;
666 }
667 }
669 ServerEvent::SessionCreated { properties } | ServerEvent::SessionUpdated { properties } => {
670 let s = properties.info;
671 let view = SessionView { id: s.id.clone(), title: display_title(&s.title) };
672 if let Some(existing) = model.sessions.iter_mut().find(|e| e.id == view.id) {
673 existing.title = view.title.clone();
674 } else {
675 model.sessions.insert(0, view);
676 }
677 if model.is_current(&s.id) {
678 model.current_session_title = display_title(&s.title);
679 }
680 }
682 ServerEvent::SessionDeleted { properties } => {
683 let id = properties.session_id.or(properties.info.map(|i| i.id));
684 if let Some(id) = id {
685 model.sessions.retain(|s| s.id != id);
686 if model.is_current(&id) {
687 model.current_session_id = None;
688 model.messages.clear();
689 model.screen = Screen::Sessions;
690 }
691 }
692 }
694 ServerEvent::Other => {}
695 }
698// ─── Helpers ─────────────────────────────────────────────────────────────────
700/// `part.text` is the full current text when present; otherwise fall back to
701/// accumulating the incremental `delta` onto whatever we already have.
702fn pick_text(text: String, delta: &Option<String>, existing: &[(String, String)], part_id: &str) -> String {
703 if !text.is_empty() {
704 return text;
705 }
706 let prior = existing.iter().find(|(pid, _)| pid == part_id).map(|(_, t)| t.clone()).unwrap_or_default();
707 match delta {
708 Some(d) => format!("{prior}{d}"),
709 None => prior,
710 }
713fn message_from_wire(env: &WireMessageEnvelope) -> MsgState {
714 let info = &env.info;
715 let mut msg = MsgState::new(info.id.clone(), info.role.clone(), info.time.created);
716 msg.streaming = info.role == "assistant" && info.time.completed.is_none() && info.error.is_none();
717 for part in &env.parts {
718 match part {
719 WirePart::Text { id, text, synthetic, .. } => {
720 if !synthetic {
721 MsgState::upsert_part(&mut msg.text_parts, id, text.clone());
722 }
723 }
724 WirePart::Reasoning { id, text, .. } => {
725 MsgState::upsert_part(&mut msg.reasoning_parts, id, text.clone());
726 }
727 WirePart::Tool { id, tool, state, .. } => {
728 let sv = protocol::tool_state_view(state);
729 msg.upsert_tool(id, ToolView { name: tool.clone(), status: sv.status, title: sv.title });
730 }
731 WirePart::Other => {}
732 }
733 }
734 msg
737fn set_last_pending(model: &mut Model, status: MessageStatus) {
738 if let Some(msg) = model.messages.iter_mut().rev().find(|m| m.status == MessageStatus::Pending) {
739 msg.status = status;
740 }
743/// Trim whitespace and any trailing `/` so paths concatenate cleanly, and
744/// default to an `http://` scheme when the user didn't type one (e.g.
745/// "192.168.1.10:4096") — otherwise the shell's URL parser rejects it.
746fn normalize_url(url: &str) -> String {
747 let trimmed = url.trim().trim_end_matches('/');
748 if trimmed.is_empty() {
749 String::new()
750 } else if trimmed.contains("://") {
751 trimmed.to_string()
752 } else {
753 format!("http://{trimmed}")
754 }
757fn display_title(title: &str) -> String {
758 let t = title.trim();
759 if t.is_empty() {
760 "Untitled".to_string()
761 } else {
762 t.to_string()
763 }
766/// Reduce an [`HttpResult`] to `Ok(body)` for 2xx, or `Err(message)` otherwise.
767fn ok_body(result: HttpResult) -> Result<String, String> {
768 match result {
769 Ok(mut response) => {
770 let status = response.status().as_u16();
771 if (200..300).contains(&status) {
772 Ok(response.take_body().unwrap_or_default())
773 } else {
774 Err(format!("Server returned status {status}"))
775 }
776 }
777 Err(e) => Err(format!("Request failed: {e}")),
778 }
781// ─── Tests ───────────────────────────────────────────────────────────────────
783#[cfg(test)]
784mod tests {
785 use super::*;
787 fn app() -> OpencodeApp {
788 OpencodeApp::default()
789 }
791 /// Put the model into a connected Chat view for the given session.
792 fn in_chat(session_id: &str) -> Model {
793 let mut model = Model::default();
794 model.server_url = "http://localhost:4096".to_string();
795 model.connected = true;
796 model.screen = Screen::Chat;
797 model.current_session_id = Some(session_id.to_string());
798 model
799 }
801 fn feed(app: &OpencodeApp, model: &mut Model, json: serde_json::Value) {
802 let _ = app.update(Event::ServerEvent(json.to_string()), model);
803 }
805 #[test]
806 fn server_url_is_normalized() {
807 let app = app();
808 let mut model = Model::default();
809 let _ = app.update(Event::ServerUrlChanged(" http://host:4096/ ".into()), &mut model);
810 assert_eq!(app.view(&model).server_url, "http://host:4096");
811 }
813 #[test]
814 fn server_url_without_scheme_defaults_to_http() {
815 let app = app();
816 let mut model = Model::default();
817 // A scheme-less host (what a user often types) must gain http://, or the
818 // shell's URL parser throws and the connect attempt crashes.
819 let _ = app.update(Event::ServerUrlChanged("192.168.1.10:4096".into()), &mut model);
820 assert_eq!(app.view(&model).server_url, "http://192.168.1.10:4096");
821 }
823 #[test]
824 fn server_url_keeps_https_scheme() {
825 let app = app();
826 let mut model = Model::default();
827 let _ = app.update(Event::ServerUrlChanged("https://host:4096".into()), &mut model);
828 assert_eq!(app.view(&model).server_url, "https://host:4096");
829 }
831 #[test]
832 fn connect_requires_a_url() {
833 let app = app();
834 let mut model = Model::default();
835 let _ = app.update(Event::Connect, &mut model);
836 assert_eq!(app.view(&model).error.as_deref(), Some("Enter a server URL"));
837 }
839 #[test]
840 fn sending_adds_optimistic_user_message_and_sets_generating() {
841 let app = app();
842 let mut model = in_chat("ses_1");
843 let _ = app.update(Event::DraftChanged("hello there".into()), &mut model);
844 let _ = app.update(Event::SendMessage("hello there".into()), &mut model);
846 let view = app.view(&model);
847 assert!(view.generating);
848 assert!(view.draft.is_empty());
849 assert_eq!(view.messages.len(), 1);
850 assert_eq!(view.messages[0].role, "user");
851 assert_eq!(view.messages[0].text, "hello there");
852 assert_eq!(view.messages[0].status, MessageStatus::Pending);
853 }
855 #[test]
856 fn empty_send_is_ignored() {
857 let app = app();
858 let mut model = in_chat("ses_1");
859 let _ = app.update(Event::SendMessage(" ".into()), &mut model);
860 assert!(app.view(&model).messages.is_empty());
861 assert!(!app.view(&model).generating);
862 }
864 #[test]
865 fn assistant_reply_streams_in_from_sse() {
866 let app = app();
867 let mut model = in_chat("ses_1");
869 // Assistant message shell arrives first.
870 feed(&app, &mut model, serde_json::json!({
871 "type": "message.updated",
872 "properties": { "info": {
873 "id": "msg_a", "role": "assistant", "sessionID": "ses_1",
874 "time": { "created": 100 }
875 }}
876 }));
877 assert_eq!(app.view(&model).messages.len(), 1);
878 assert!(app.view(&model).messages[0].streaming);
880 // Two text deltas for the same part accumulate into full text.
881 feed(&app, &mut model, serde_json::json!({
882 "type": "message.part.updated",
883 "properties": { "part": {
884 "id": "prt_1", "messageID": "msg_a", "sessionID": "ses_1",
885 "type": "text", "text": "Hello"
886 }}
887 }));
888 feed(&app, &mut model, serde_json::json!({
889 "type": "message.part.updated",
890 "properties": { "part": {
891 "id": "prt_1", "messageID": "msg_a", "sessionID": "ses_1",
892 "type": "text", "text": "Hello, world"
893 }}
894 }));
896 let view = app.view(&model);
897 assert_eq!(view.messages[0].role, "assistant");
898 assert_eq!(view.messages[0].text, "Hello, world");
899 }
901 #[test]
902 fn text_delta_accumulates_when_full_text_absent() {
903 let app = app();
904 let mut model = in_chat("ses_1");
905 feed(&app, &mut model, serde_json::json!({
906 "type": "message.updated",
907 "properties": { "info": { "id": "msg_a", "role": "assistant", "sessionID": "ses_1", "time": {"created": 1}}}
908 }));
909 for delta in ["Wor", "ld"] {
910 feed(&app, &mut model, serde_json::json!({
911 "type": "message.part.updated",
912 "properties": {
913 "part": { "id": "p", "messageID": "msg_a", "sessionID": "ses_1", "type": "text", "text": "" },
914 "delta": delta
915 }
916 }));
917 }
918 assert_eq!(app.view(&model).messages[0].text, "World");
919 }
921 #[test]
922 fn user_message_from_sse_is_not_duplicated() {
923 let app = app();
924 let mut model = in_chat("ses_1");
925 let _ = app.update(Event::SendMessage("hi".into()), &mut model);
926 // Server echoes the user message on the stream — must be ignored.
927 feed(&app, &mut model, serde_json::json!({
928 "type": "message.updated",
929 "properties": { "info": { "id": "msg_user", "role": "user", "sessionID": "ses_1", "time": {"created": 5}}}
930 }));
931 let users = app.view(&model).messages.iter().filter(|m| m.role == "user").count();
932 assert_eq!(users, 1);
933 }
935 #[test]
936 fn session_idle_clears_generating() {
937 let app = app();
938 let mut model = in_chat("ses_1");
939 let _ = app.update(Event::SendMessage("hi".into()), &mut model);
940 assert!(app.view(&model).generating);
941 feed(&app, &mut model, serde_json::json!({
942 "type": "session.idle", "properties": { "sessionID": "ses_1" }
943 }));
944 assert!(!app.view(&model).generating);
945 }
947 #[test]
948 fn idle_for_other_session_is_ignored() {
949 let app = app();
950 let mut model = in_chat("ses_1");
951 let _ = app.update(Event::SendMessage("hi".into()), &mut model);
952 feed(&app, &mut model, serde_json::json!({
953 "type": "session.idle", "properties": { "sessionID": "ses_other" }
954 }));
955 assert!(app.view(&model).generating);
956 }
958 #[test]
959 fn reasoning_and_tool_parts_are_surfaced() {
960 let app = app();
961 let mut model = in_chat("ses_1");
962 feed(&app, &mut model, serde_json::json!({
963 "type": "message.updated",
964 "properties": { "info": { "id": "m", "role": "assistant", "sessionID": "ses_1", "time": {"created": 1}}}
965 }));
966 feed(&app, &mut model, serde_json::json!({
967 "type": "message.part.updated",
968 "properties": { "part": { "id": "r", "messageID": "m", "type": "reasoning", "text": "thinking..." }}
969 }));
970 feed(&app, &mut model, serde_json::json!({
971 "type": "message.part.updated",
972 "properties": { "part": {
973 "id": "t", "messageID": "m", "type": "tool", "tool": "bash",
974 "state": { "status": "completed", "title": "ls -la" }
975 }}
976 }));
977 let msg = &app.view(&model).messages[0];
978 assert_eq!(msg.reasoning.as_deref(), Some("thinking..."));
979 assert_eq!(msg.tools.len(), 1);
980 assert_eq!(msg.tools[0].name, "bash");
981 assert_eq!(msg.tools[0].status, "completed");
982 assert_eq!(msg.tools[0].title.as_deref(), Some("ls -la"));
983 }
985 #[test]
986 fn session_created_event_updates_list() {
987 let app = app();
988 let mut model = in_chat("ses_1");
989 feed(&app, &mut model, serde_json::json!({
990 "type": "session.created",
991 "properties": { "info": { "id": "ses_new", "title": "Fresh" }}
992 }));
993 assert!(app.view(&model).sessions.iter().any(|s| s.id == "ses_new" && s.title == "Fresh"));
994 }
996 #[test]
997 fn unknown_event_types_are_ignored() {
998 let app = app();
999 let mut model = in_chat("ses_1");
1000 feed(&app, &mut model, serde_json::json!({
1001 "type": "pty.created", "properties": { "whatever": true }
1002 }));
1003 feed(&app, &mut model, serde_json::json!({ "type": "totally.new.event" }));
1004 // No panic, no state change.
1005 assert!(app.view(&model).messages.is_empty());
1008 #[test]
1009 fn messages_loaded_parses_info_and_parts() {
1010 let app = app();
1011 let mut model = in_chat("ses_1");
1012 let body = serde_json::json!([
1013 { "info": { "id": "m1", "role": "user", "sessionID": "ses_1", "time": {"created": 1} },
1014 "parts": [{ "id": "p1", "type": "text", "text": "Question?" }] },
1015 { "info": { "id": "m2", "role": "assistant", "sessionID": "ses_1", "time": {"created": 2, "completed": 3} },
1016 "parts": [{ "id": "p2", "type": "text", "text": "Answer." }] }
1017 ]).to_string();
1018 let result: HttpResult = Ok(crux_http::testing::ResponseBuilder::ok().body(body).build());
1019 let _ = app.update(Event::MessagesLoaded("ses_1".into(), result), &mut model);
1021 let view = app.view(&model);
1022 assert_eq!(view.messages.len(), 2);
1023 assert_eq!(view.messages[0].text, "Question?");
1024 assert_eq!(view.messages[1].text, "Answer.");
1025 assert!(!view.messages[1].streaming);
1026 assert!(!view.generating);