1package workspace
2
3import (
4 "context"
5 "errors"
6 "fmt"
7 "log/slog"
8 "strings"
9 "sync"
10 "time"
11
12 tea "charm.land/bubbletea/v2"
13 "github.com/charmbracelet/crush/internal/agent/notify"
14 "github.com/charmbracelet/crush/internal/agent/tools/mcp"
15 "github.com/charmbracelet/crush/internal/client"
16 "github.com/charmbracelet/crush/internal/config"
17 "github.com/charmbracelet/crush/internal/history"
18 "github.com/charmbracelet/crush/internal/log"
19 "github.com/charmbracelet/crush/internal/lsp"
20 "github.com/charmbracelet/crush/internal/message"
21 "github.com/charmbracelet/crush/internal/oauth"
22 "github.com/charmbracelet/crush/internal/permission"
23 "github.com/charmbracelet/crush/internal/proto"
24 "github.com/charmbracelet/crush/internal/pubsub"
25 "github.com/charmbracelet/crush/internal/session"
26 "github.com/charmbracelet/crush/internal/skills"
27 "github.com/charmbracelet/x/powernap/pkg/lsp/protocol"
28)
29
30// ClientWorkspace implements the Workspace interface by delegating all
31// operations to a remote server via the client SDK. It caches the
32// proto.Workspace returned at creation time and refreshes it after
33// config-mutating operations.
34type ClientWorkspace struct {
35 client *client.Client
36
37 mu sync.RWMutex
38 ws proto.Workspace
39 skills *skills.Manager
40}
41
42// NewClientWorkspace creates a new ClientWorkspace that proxies all
43// operations through the given client SDK. The ws parameter is the
44// proto.Workspace snapshot returned by the server at creation time. The
45// snapshot's Skills field seeds a process-local skills.Manager so the
46// TUI sees discovery state before the first SSE event arrives. The
47// manager is constructed with WithGlobalMirror because the client
48// process represents exactly one workspace and the TUI reads
49// skills.GetLatestStates directly at construction time.
50func NewClientWorkspace(c *client.Client, ws proto.Workspace) *ClientWorkspace {
51 if ws.Config != nil {
52 ws.Config.SetupAgents()
53 }
54 states := protoToSkillStates(ws.Skills)
55 mgr := skills.NewManager(nil, nil, states, skills.WithGlobalMirror())
56 return &ClientWorkspace{
57 client: c,
58 ws: ws,
59 skills: mgr,
60 }
61}
62
63// refreshWorkspace re-fetches the workspace from the server, updating
64// the cached snapshot. Called after config-mutating operations.
65func (w *ClientWorkspace) refreshWorkspace() {
66 updated, err := w.client.GetWorkspace(context.Background(), w.workspaceID())
67 if err != nil {
68 slog.Error("Failed to refresh workspace", "error", err)
69 return
70 }
71 if updated.Config != nil {
72 updated.Config.SetupAgents()
73 }
74 w.mu.Lock()
75 w.ws = *updated
76 w.mu.Unlock()
77}
78
79// cached returns a snapshot of the cached workspace.
80func (w *ClientWorkspace) cached() proto.Workspace {
81 w.mu.RLock()
82 defer w.mu.RUnlock()
83 return w.ws
84}
85
86// workspaceID returns the cached workspace ID.
87func (w *ClientWorkspace) workspaceID() string {
88 return w.cached().ID
89}
90
91// -- Sessions --
92
93func (w *ClientWorkspace) CreateSession(ctx context.Context, title string) (session.Session, error) {
94 sess, err := w.client.CreateSession(ctx, w.workspaceID(), title)
95 if err != nil {
96 return session.Session{}, err
97 }
98 return protoToSession(*sess), nil
99}
100
101func (w *ClientWorkspace) GetSession(ctx context.Context, sessionID string) (session.Session, error) {
102 sess, err := w.client.GetSession(ctx, w.workspaceID(), sessionID)
103 if err != nil {
104 return session.Session{}, err
105 }
106 return protoToSession(*sess), nil
107}
108
109func (w *ClientWorkspace) ListSessions(ctx context.Context) ([]session.Session, error) {
110 protoSessions, err := w.client.ListSessions(ctx, w.workspaceID())
111 if err != nil {
112 return nil, err
113 }
114 sessions := make([]session.Session, len(protoSessions))
115 for i, s := range protoSessions {
116 sessions[i] = protoToSession(s)
117 }
118 return sessions, nil
119}
120
121func (w *ClientWorkspace) SaveSession(ctx context.Context, sess session.Session) (session.Session, error) {
122 saved, err := w.client.SaveSession(ctx, w.workspaceID(), sessionToProto(sess))
123 if err != nil {
124 return session.Session{}, err
125 }
126 return protoToSession(*saved), nil
127}
128
129func (w *ClientWorkspace) DeleteSession(ctx context.Context, sessionID string) error {
130 return w.client.DeleteSession(ctx, w.workspaceID(), sessionID)
131}
132
133func (w *ClientWorkspace) CreateAgentToolSessionID(messageID, toolCallID string) string {
134 return fmt.Sprintf("%s$$%s", messageID, toolCallID)
135}
136
137func (w *ClientWorkspace) ParseAgentToolSessionID(sessionID string) (string, string, bool) {
138 parts := strings.Split(sessionID, "$$")
139 if len(parts) != 2 {
140 return "", "", false
141 }
142 return parts[0], parts[1], true
143}
144
145// SetCurrentSession reports the session this client is currently
146// viewing to the server. Empty sessionID clears the entry. Errors
147// are propagated to the caller; the TUI logs and ignores them since
148// the presence record is a hint, not correctness-critical state.
149func (w *ClientWorkspace) SetCurrentSession(ctx context.Context, sessionID string) error {
150 return w.client.SetCurrentSession(ctx, w.workspaceID(), sessionID)
151}
152
153// -- Messages --
154
155func (w *ClientWorkspace) ListMessages(ctx context.Context, sessionID string) ([]message.Message, error) {
156 msgs, err := w.client.ListMessages(ctx, w.workspaceID(), sessionID)
157 if err != nil {
158 return nil, err
159 }
160 return protoToMessages(msgs), nil
161}
162
163func (w *ClientWorkspace) ListUserMessages(ctx context.Context, sessionID string) ([]message.Message, error) {
164 msgs, err := w.client.ListUserMessages(ctx, w.workspaceID(), sessionID)
165 if err != nil {
166 return nil, err
167 }
168 return protoToMessages(msgs), nil
169}
170
171func (w *ClientWorkspace) ListAllUserMessages(ctx context.Context) ([]message.Message, error) {
172 msgs, err := w.client.ListAllUserMessages(ctx, w.workspaceID())
173 if err != nil {
174 return nil, err
175 }
176 return protoToMessages(msgs), nil
177}
178
179// -- Agent --
180
181func (w *ClientWorkspace) AgentRun(ctx context.Context, sessionID, prompt string, attachments ...message.Attachment) error {
182 // The interactive TUI does not consume notify.RunComplete for
183 // completion detection (it observes message events directly),
184 // so passing an empty RunID is correct here: it skips the
185 // correlator stamping path without functional consequences.
186 return w.client.SendMessage(ctx, w.workspaceID(), sessionID, "", prompt, attachments...)
187}
188
189func (w *ClientWorkspace) AgentCancel(sessionID string) {
190 _ = w.client.CancelAgentSession(context.Background(), w.workspaceID(), sessionID)
191}
192
193func (w *ClientWorkspace) AgentIsBusy() bool {
194 info, err := w.client.GetAgentInfo(context.Background(), w.workspaceID())
195 if err != nil {
196 return false
197 }
198 return info.IsBusy
199}
200
201func (w *ClientWorkspace) AgentIsSessionBusy(sessionID string) bool {
202 info, err := w.client.GetAgentSessionInfo(context.Background(), w.workspaceID(), sessionID)
203 if err != nil {
204 return false
205 }
206 return info.IsBusy
207}
208
209func (w *ClientWorkspace) AgentModel() AgentModel {
210 info, err := w.client.GetAgentInfo(context.Background(), w.workspaceID())
211 if err != nil {
212 return AgentModel{}
213 }
214 return AgentModel{
215 CatwalkCfg: info.Model,
216 ModelCfg: info.ModelCfg,
217 }
218}
219
220func (w *ClientWorkspace) AgentIsReady() bool {
221 info, err := w.client.GetAgentInfo(context.Background(), w.workspaceID())
222 if err != nil {
223 return false
224 }
225 return info.IsReady
226}
227
228func (w *ClientWorkspace) AgentQueuedPrompts(sessionID string) int {
229 count, err := w.client.GetAgentSessionQueuedPrompts(context.Background(), w.workspaceID(), sessionID)
230 if err != nil {
231 return 0
232 }
233 return count
234}
235
236func (w *ClientWorkspace) AgentQueuedPromptsList(sessionID string) []string {
237 prompts, err := w.client.GetAgentSessionQueuedPromptsList(context.Background(), w.workspaceID(), sessionID)
238 if err != nil {
239 return nil
240 }
241 return prompts
242}
243
244func (w *ClientWorkspace) AgentClearQueue(sessionID string) {
245 _ = w.client.ClearAgentSessionQueuedPrompts(context.Background(), w.workspaceID(), sessionID)
246}
247
248func (w *ClientWorkspace) AgentSummarize(ctx context.Context, sessionID string) error {
249 return w.client.AgentSummarizeSession(ctx, w.workspaceID(), sessionID)
250}
251
252func (w *ClientWorkspace) UpdateAgentModel(ctx context.Context) error {
253 return w.client.UpdateAgent(ctx, w.workspaceID())
254}
255
256func (w *ClientWorkspace) InitCoderAgent(ctx context.Context) error {
257 return w.client.InitiateAgentProcessing(ctx, w.workspaceID())
258}
259
260func (w *ClientWorkspace) GetDefaultSmallModel(providerID string) config.SelectedModel {
261 model, err := w.client.GetDefaultSmallModel(context.Background(), w.workspaceID(), providerID)
262 if err != nil {
263 return config.SelectedModel{}
264 }
265 return *model
266}
267
268// -- Permissions --
269
270func (w *ClientWorkspace) PermissionGrant(perm permission.PermissionRequest) bool {
271 resolved, _ := w.client.GrantPermission(context.Background(), w.workspaceID(), proto.PermissionGrant{
272 Permission: proto.PermissionRequest{
273 ID: perm.ID,
274 SessionID: perm.SessionID,
275 ToolCallID: perm.ToolCallID,
276 ToolName: perm.ToolName,
277 Description: perm.Description,
278 Action: perm.Action,
279 Path: perm.Path,
280 Params: perm.Params,
281 },
282 Action: proto.PermissionAllow,
283 })
284 return resolved
285}
286
287func (w *ClientWorkspace) PermissionGrantPersistent(perm permission.PermissionRequest) bool {
288 resolved, _ := w.client.GrantPermission(context.Background(), w.workspaceID(), proto.PermissionGrant{
289 Permission: proto.PermissionRequest{
290 ID: perm.ID,
291 SessionID: perm.SessionID,
292 ToolCallID: perm.ToolCallID,
293 ToolName: perm.ToolName,
294 Description: perm.Description,
295 Action: perm.Action,
296 Path: perm.Path,
297 Params: perm.Params,
298 },
299 Action: proto.PermissionAllowForSession,
300 })
301 return resolved
302}
303
304func (w *ClientWorkspace) PermissionDeny(perm permission.PermissionRequest) bool {
305 resolved, _ := w.client.GrantPermission(context.Background(), w.workspaceID(), proto.PermissionGrant{
306 Permission: proto.PermissionRequest{
307 ID: perm.ID,
308 SessionID: perm.SessionID,
309 ToolCallID: perm.ToolCallID,
310 ToolName: perm.ToolName,
311 Description: perm.Description,
312 Action: perm.Action,
313 Path: perm.Path,
314 Params: perm.Params,
315 },
316 Action: proto.PermissionDeny,
317 })
318 return resolved
319}
320
321func (w *ClientWorkspace) PermissionSkipRequests() bool {
322 skip, err := w.client.GetPermissionsSkipRequests(context.Background(), w.workspaceID())
323 if err != nil {
324 return false
325 }
326 return skip
327}
328
329func (w *ClientWorkspace) PermissionSetSkipRequests(skip bool) {
330 _ = w.client.SetPermissionsSkipRequests(context.Background(), w.workspaceID(), skip)
331}
332
333// -- FileTracker --
334
335func (w *ClientWorkspace) FileTrackerRecordRead(ctx context.Context, sessionID, path string) {
336 _ = w.client.FileTrackerRecordRead(ctx, w.workspaceID(), sessionID, path)
337}
338
339func (w *ClientWorkspace) FileTrackerLastReadTime(ctx context.Context, sessionID, path string) time.Time {
340 t, err := w.client.FileTrackerLastReadTime(ctx, w.workspaceID(), sessionID, path)
341 if err != nil {
342 return time.Time{}
343 }
344 return t
345}
346
347func (w *ClientWorkspace) FileTrackerListReadFiles(ctx context.Context, sessionID string) ([]string, error) {
348 return w.client.FileTrackerListReadFiles(ctx, w.workspaceID(), sessionID)
349}
350
351// -- History --
352
353func (w *ClientWorkspace) ListSessionHistory(ctx context.Context, sessionID string) ([]history.File, error) {
354 files, err := w.client.ListSessionHistoryFiles(ctx, w.workspaceID(), sessionID)
355 if err != nil {
356 return nil, err
357 }
358 return protoToFiles(files), nil
359}
360
361// -- LSP --
362
363func (w *ClientWorkspace) LSPStart(ctx context.Context, path string) {
364 _ = w.client.LSPStart(ctx, w.workspaceID(), path)
365}
366
367func (w *ClientWorkspace) LSPStopAll(ctx context.Context) {
368 _ = w.client.LSPStopAll(ctx, w.workspaceID())
369}
370
371func (w *ClientWorkspace) LSPGetStates() map[string]LSPClientInfo {
372 states, err := w.client.GetLSPs(context.Background(), w.workspaceID())
373 if err != nil {
374 return nil
375 }
376 result := make(map[string]LSPClientInfo, len(states))
377 for k, v := range states {
378 result[k] = LSPClientInfo{
379 Name: v.Name,
380 State: v.State,
381 Error: v.Error,
382 DiagnosticCount: v.DiagnosticCount,
383 ConnectedAt: v.ConnectedAt,
384 }
385 }
386 return result
387}
388
389func (w *ClientWorkspace) LSPGetDiagnosticCounts(name string) lsp.DiagnosticCounts {
390 diags, err := w.client.GetLSPDiagnostics(context.Background(), w.workspaceID(), name)
391 if err != nil {
392 return lsp.DiagnosticCounts{}
393 }
394 var counts lsp.DiagnosticCounts
395 for _, fileDiags := range diags {
396 for _, d := range fileDiags {
397 switch d.Severity {
398 case protocol.SeverityError:
399 counts.Error++
400 case protocol.SeverityWarning:
401 counts.Warning++
402 case protocol.SeverityInformation:
403 counts.Information++
404 case protocol.SeverityHint:
405 counts.Hint++
406 }
407 }
408 }
409 return counts
410}
411
412// -- Config (read-only) --
413
414func (w *ClientWorkspace) Config() *config.Config {
415 return w.cached().Config
416}
417
418func (w *ClientWorkspace) WorkingDir() string {
419 return w.cached().Path
420}
421
422func (w *ClientWorkspace) Resolver() config.VariableResolver {
423 return config.IdentityResolver()
424}
425
426// -- Config mutations --
427
428func (w *ClientWorkspace) UpdatePreferredModel(scope config.Scope, modelType config.SelectedModelType, model config.SelectedModel) error {
429 err := w.client.UpdatePreferredModel(context.Background(), w.workspaceID(), scope, modelType, model)
430 if err == nil {
431 w.refreshWorkspace()
432 }
433 return err
434}
435
436func (w *ClientWorkspace) SetCompactMode(scope config.Scope, enabled bool) error {
437 err := w.client.SetCompactMode(context.Background(), w.workspaceID(), scope, enabled)
438 if err == nil {
439 w.refreshWorkspace()
440 }
441 return err
442}
443
444func (w *ClientWorkspace) SetProviderAPIKey(scope config.Scope, providerID string, apiKey any) error {
445 err := w.client.SetProviderAPIKey(context.Background(), w.workspaceID(), scope, providerID, apiKey)
446 if err == nil {
447 w.refreshWorkspace()
448 }
449 return err
450}
451
452func (w *ClientWorkspace) SetConfigField(scope config.Scope, key string, value any) error {
453 err := w.client.SetConfigField(context.Background(), w.workspaceID(), scope, key, value)
454 if err == nil {
455 w.refreshWorkspace()
456 }
457 return err
458}
459
460func (w *ClientWorkspace) RemoveConfigField(scope config.Scope, key string) error {
461 err := w.client.RemoveConfigField(context.Background(), w.workspaceID(), scope, key)
462 if err == nil {
463 w.refreshWorkspace()
464 }
465 return err
466}
467
468func (w *ClientWorkspace) ImportCopilot() (*oauth.Token, bool) {
469 token, ok, err := w.client.ImportCopilot(context.Background(), w.workspaceID())
470 if err != nil {
471 return nil, false
472 }
473 if ok {
474 w.refreshWorkspace()
475 }
476 return token, ok
477}
478
479func (w *ClientWorkspace) RefreshOAuthToken(ctx context.Context, scope config.Scope, providerID string) error {
480 err := w.client.RefreshOAuthToken(ctx, w.workspaceID(), scope, providerID)
481 if err == nil {
482 w.refreshWorkspace()
483 }
484 return err
485}
486
487// -- Project lifecycle --
488
489func (w *ClientWorkspace) ProjectNeedsInitialization() (bool, error) {
490 return w.client.ProjectNeedsInitialization(context.Background(), w.workspaceID())
491}
492
493func (w *ClientWorkspace) MarkProjectInitialized() error {
494 return w.client.MarkProjectInitialized(context.Background(), w.workspaceID())
495}
496
497func (w *ClientWorkspace) InitializePrompt() (string, error) {
498 return w.client.GetInitializePrompt(context.Background(), w.workspaceID())
499}
500
501func (w *ClientWorkspace) ListSkills(ctx context.Context) ([]skills.CatalogEntry, error) {
502 entries, err := w.client.ListSkills(ctx, w.workspaceID())
503 if err != nil {
504 return nil, err
505 }
506 result := make([]skills.CatalogEntry, len(entries))
507 for i, entry := range entries {
508 result[i] = skills.CatalogEntry{
509 ID: entry.ID,
510 Name: entry.Name,
511 Description: entry.Description,
512 Label: entry.Label,
513 Source: skills.SourceType(entry.Source),
514 UserInvocable: entry.UserInvocable,
515 }
516 }
517 return result, nil
518}
519
520func (w *ClientWorkspace) ReadSkill(ctx context.Context, skillID string) ([]byte, skills.SkillReadResult, error) {
521 resp, err := w.client.ReadSkill(ctx, w.workspaceID(), skillID)
522 if err != nil {
523 return nil, skills.SkillReadResult{}, err
524 }
525 return resp.Content, skills.SkillReadResult{
526 Name: resp.Result.Name,
527 Description: resp.Result.Description,
528 Source: skills.SourceType(resp.Result.Source),
529 Builtin: resp.Result.Builtin,
530 }, nil
531}
532
533// -- MCP operations --
534
535func (w *ClientWorkspace) MCPGetStates() map[string]mcp.ClientInfo {
536 states, err := w.client.MCPGetStates(context.Background(), w.workspaceID())
537 if err != nil {
538 return nil
539 }
540 result := make(map[string]mcp.ClientInfo, len(states))
541 for k, v := range states {
542 result[k] = mcp.ClientInfo{
543 Name: v.Name,
544 State: mcp.State(v.State),
545 Error: v.Error,
546 Counts: mcp.Counts{
547 Tools: v.ToolCount,
548 Prompts: v.PromptCount,
549 Resources: v.ResourceCount,
550 },
551 ConnectedAt: v.ConnectedAt,
552 }
553 }
554 return result
555}
556
557func (w *ClientWorkspace) MCPRefreshPrompts(ctx context.Context, name string) {
558 _ = w.client.MCPRefreshPrompts(ctx, w.workspaceID(), name)
559}
560
561func (w *ClientWorkspace) MCPRefreshResources(ctx context.Context, name string) {
562 _ = w.client.MCPRefreshResources(ctx, w.workspaceID(), name)
563}
564
565func (w *ClientWorkspace) RefreshMCPTools(ctx context.Context, name string) {
566 _ = w.client.RefreshMCPTools(ctx, w.workspaceID(), name)
567}
568
569func (w *ClientWorkspace) ReadMCPResource(ctx context.Context, name, uri string) ([]MCPResourceContents, error) {
570 contents, err := w.client.ReadMCPResource(ctx, w.workspaceID(), name, uri)
571 if err != nil {
572 return nil, err
573 }
574 result := make([]MCPResourceContents, len(contents))
575 for i, c := range contents {
576 result[i] = MCPResourceContents{
577 URI: c.URI,
578 MIMEType: c.MIMEType,
579 Text: c.Text,
580 Blob: c.Blob,
581 }
582 }
583 return result, nil
584}
585
586func (w *ClientWorkspace) GetMCPPrompt(clientID, promptID string, args map[string]string) (string, error) {
587 return w.client.GetMCPPrompt(context.Background(), w.workspaceID(), clientID, promptID, args)
588}
589
590func (w *ClientWorkspace) EnableDockerMCP(ctx context.Context) error {
591 return w.client.EnableDockerMCP(ctx, w.workspaceID())
592}
593
594func (w *ClientWorkspace) DisableDockerMCP() error {
595 return w.client.DisableDockerMCP(context.Background(), w.workspaceID())
596}
597
598// -- Lifecycle --
599
600func (w *ClientWorkspace) Subscribe(program *tea.Program) {
601 defer log.RecoverPanic("ClientWorkspace.Subscribe", func() {
602 slog.Info("TUI subscription panic: attempting graceful shutdown")
603 program.Quit()
604 })
605
606 evc, err := w.client.SubscribeEvents(context.Background(), w.workspaceID())
607 if err != nil {
608 slog.Error("Failed to subscribe to events", "error", err)
609 return
610 }
611
612 w.consumeEvents(evc, program.Send)
613}
614
615// consumeEvents drives the workspace event loop. It is split out from
616// Subscribe so tests can drive it without a real *tea.Program.
617// ConfigChanged events trigger a workspace refresh; all other events
618// are translated into domain types and forwarded to send.
619func (w *ClientWorkspace) consumeEvents(evc <-chan any, send func(tea.Msg)) {
620 for ev := range evc {
621 if _, ok := ev.(pubsub.Event[proto.ConfigChanged]); ok {
622 w.refreshWorkspace()
623 continue
624 }
625 translated := w.translateEvent(ev)
626 if translated != nil && send != nil {
627 send(translated)
628 }
629 }
630}
631
632func (w *ClientWorkspace) Shutdown() {
633 _ = w.client.DeleteWorkspace(context.Background(), w.workspaceID())
634}
635
636// translateEvent converts proto-typed SSE events into the domain types
637// that the TUI's Update() method expects. Skills events also update the
638// process-local skills.Manager so callers reading
639// skills.GetLatestStates see fresh data.
640func (w *ClientWorkspace) translateEvent(ev any) tea.Msg {
641 switch e := ev.(type) {
642 case pubsub.Event[proto.LSPEvent]:
643 return pubsub.Event[LSPEvent]{
644 Type: e.Type,
645 Payload: LSPEvent{
646 Type: LSPEventType(e.Payload.Type),
647 Name: e.Payload.Name,
648 State: e.Payload.State,
649 Error: e.Payload.Error,
650 DiagnosticCount: e.Payload.DiagnosticCount,
651 },
652 }
653 case pubsub.Event[proto.MCPEvent]:
654 return pubsub.Event[mcp.Event]{
655 Type: e.Type,
656 Payload: mcp.Event{
657 Type: protoToMCPEventType(e.Payload.Type),
658 Name: e.Payload.Name,
659 State: mcp.State(e.Payload.State),
660 Error: e.Payload.Error,
661 Counts: mcp.Counts{
662 Tools: e.Payload.ToolCount,
663 Prompts: e.Payload.PromptCount,
664 Resources: e.Payload.ResourceCount,
665 },
666 },
667 }
668 case pubsub.Event[proto.PermissionRequest]:
669 return pubsub.Event[permission.PermissionRequest]{
670 Type: e.Type,
671 Payload: permission.PermissionRequest{
672 ID: e.Payload.ID,
673 SessionID: e.Payload.SessionID,
674 ToolCallID: e.Payload.ToolCallID,
675 ToolName: e.Payload.ToolName,
676 Description: e.Payload.Description,
677 Action: e.Payload.Action,
678 Path: e.Payload.Path,
679 Params: e.Payload.Params,
680 },
681 }
682 case pubsub.Event[proto.PermissionNotification]:
683 return pubsub.Event[permission.PermissionNotification]{
684 Type: e.Type,
685 Payload: permission.PermissionNotification{
686 ToolCallID: e.Payload.ToolCallID,
687 Granted: e.Payload.Granted,
688 Denied: e.Payload.Denied,
689 },
690 }
691 case pubsub.Event[proto.Message]:
692 return pubsub.Event[message.Message]{
693 Type: e.Type,
694 Payload: protoToMessage(e.Payload),
695 }
696 case pubsub.Event[proto.Session]:
697 return pubsub.Event[session.Session]{
698 Type: e.Type,
699 Payload: protoToSession(e.Payload),
700 }
701 case pubsub.Event[proto.File]:
702 return pubsub.Event[history.File]{
703 Type: e.Type,
704 Payload: protoToFile(e.Payload),
705 }
706 case pubsub.Event[proto.AgentEvent]:
707 return pubsub.Event[notify.Notification]{
708 Type: e.Type,
709 Payload: notify.Notification{
710 SessionID: e.Payload.SessionID,
711 SessionTitle: e.Payload.SessionTitle,
712 Type: notify.Type(e.Payload.Type),
713 },
714 }
715 case pubsub.Event[proto.RunComplete]:
716 // Translate the wire-level proto.RunComplete back into the
717 // agent's domain notify.RunComplete. Without this case the
718 // default branch below warns on every run completion in the
719 // server-mode TUI, even though the TUI itself doesn't act
720 // on RunComplete — converting silently keeps the workspace
721 // event bridge symmetric with the server-side wrapEvent.
722 return pubsub.Event[notify.RunComplete]{
723 Type: e.Type,
724 Payload: notify.RunComplete{
725 SessionID: e.Payload.SessionID,
726 RunID: e.Payload.RunID,
727 MessageID: e.Payload.MessageID,
728 Text: e.Payload.Text,
729 Error: e.Payload.Error,
730 Cancelled: e.Payload.Cancelled,
731 },
732 }
733 case pubsub.Event[proto.SkillsEvent]:
734 states := protoToSkillStates(e.Payload.States)
735 if w.skills != nil {
736 w.skills.SetLatestStates(states)
737 }
738 return pubsub.Event[skills.Event]{
739 Type: e.Type,
740 Payload: skills.Event{States: states},
741 }
742 default:
743 slog.Warn("Unknown event type in translateEvent", "type", fmt.Sprintf("%T", ev))
744 return nil
745 }
746}
747
748func protoToMCPEventType(t proto.MCPEventType) mcp.EventType {
749 switch t {
750 case proto.MCPEventStateChanged:
751 return mcp.EventStateChanged
752 case proto.MCPEventToolsListChanged:
753 return mcp.EventToolsListChanged
754 case proto.MCPEventPromptsListChanged:
755 return mcp.EventPromptsListChanged
756 case proto.MCPEventResourcesListChanged:
757 return mcp.EventResourcesListChanged
758 default:
759 return mcp.EventStateChanged
760 }
761}
762
763// protoToSession converts a wire-level proto.Session into the domain
764// session.Session. Fields that exist only on the wire (computed-on-read
765// signals like IsBusy, and any future presence counters) are
766// intentionally dropped here: session.Session models persisted state,
767// not transient runtime signals. UI features that need those signals
768// should either extend session.Session or read them from the proto
769// payload directly before this conversion runs.
770func protoToSession(s proto.Session) session.Session {
771 return session.Session{
772 ID: s.ID,
773 ParentSessionID: s.ParentSessionID,
774 Title: s.Title,
775 SummaryMessageID: s.SummaryMessageID,
776 MessageCount: s.MessageCount,
777 PromptTokens: s.PromptTokens,
778 CompletionTokens: s.CompletionTokens,
779 Cost: s.Cost,
780 Todos: protoToTodos(s.Todos),
781 CreatedAt: s.CreatedAt,
782 UpdatedAt: s.UpdatedAt,
783 }
784}
785
786func protoToTodos(todos []proto.Todo) []session.Todo {
787 if len(todos) == 0 {
788 return nil
789 }
790 out := make([]session.Todo, len(todos))
791 for i, t := range todos {
792 out[i] = session.Todo{
793 Content: t.Content,
794 Status: session.TodoStatus(t.Status),
795 ActiveForm: t.ActiveForm,
796 }
797 }
798 return out
799}
800
801func protoToFile(f proto.File) history.File {
802 return history.File{
803 ID: f.ID,
804 SessionID: f.SessionID,
805 Path: f.Path,
806 Content: f.Content,
807 Version: f.Version,
808 CreatedAt: f.CreatedAt,
809 UpdatedAt: f.UpdatedAt,
810 }
811}
812
813func protoToMessage(m proto.Message) message.Message {
814 msg := message.Message{
815 ID: m.ID,
816 SessionID: m.SessionID,
817 Role: message.MessageRole(m.Role),
818 Model: m.Model,
819 Provider: m.Provider,
820 CreatedAt: m.CreatedAt,
821 UpdatedAt: m.UpdatedAt,
822 }
823
824 for _, p := range m.Parts {
825 switch v := p.(type) {
826 case proto.TextContent:
827 msg.Parts = append(msg.Parts, message.TextContent{Text: v.Text})
828 case proto.ReasoningContent:
829 msg.Parts = append(msg.Parts, message.ReasoningContent{
830 Thinking: v.Thinking,
831 Signature: v.Signature,
832 StartedAt: v.StartedAt,
833 FinishedAt: v.FinishedAt,
834 })
835 case proto.ToolCall:
836 msg.Parts = append(msg.Parts, message.ToolCall{
837 ID: v.ID,
838 Name: v.Name,
839 Input: v.Input,
840 Finished: v.Finished,
841 })
842 case proto.ToolResult:
843 msg.Parts = append(msg.Parts, message.ToolResult{
844 ToolCallID: v.ToolCallID,
845 Name: v.Name,
846 Content: v.Content,
847 Data: v.Data,
848 MIMEType: v.MIMEType,
849 Metadata: v.Metadata,
850 IsError: v.IsError,
851 })
852 case proto.Finish:
853 msg.Parts = append(msg.Parts, message.Finish{
854 Reason: message.FinishReason(v.Reason),
855 Time: v.Time,
856 Message: v.Message,
857 Details: v.Details,
858 })
859 case proto.ImageURLContent:
860 msg.Parts = append(msg.Parts, message.ImageURLContent{URL: v.URL, Detail: v.Detail})
861 case proto.BinaryContent:
862 msg.Parts = append(msg.Parts, message.BinaryContent{Path: v.Path, MIMEType: v.MIMEType, Data: v.Data})
863 }
864 }
865
866 return msg
867}
868
869func protoToMessages(msgs []proto.Message) []message.Message {
870 out := make([]message.Message, len(msgs))
871 for i, m := range msgs {
872 out[i] = protoToMessage(m)
873 }
874 return out
875}
876
877func protoToFiles(files []proto.File) []history.File {
878 out := make([]history.File, len(files))
879 for i, f := range files {
880 out[i] = protoToFile(f)
881 }
882 return out
883}
884
885func sessionToProto(s session.Session) proto.Session {
886 return proto.Session{
887 ID: s.ID,
888 ParentSessionID: s.ParentSessionID,
889 Title: s.Title,
890 SummaryMessageID: s.SummaryMessageID,
891 MessageCount: s.MessageCount,
892 PromptTokens: s.PromptTokens,
893 CompletionTokens: s.CompletionTokens,
894 Cost: s.Cost,
895 Todos: todosToProto(s.Todos),
896 CreatedAt: s.CreatedAt,
897 UpdatedAt: s.UpdatedAt,
898 }
899}
900
901// protoToSkillStates reconstructs internal skill state slices from
902// their wire representation. Non-empty Error strings are turned into
903// synthetic error values; the TUI never type-asserts on Err.
904func protoToSkillStates(in []proto.SkillState) []*skills.SkillState {
905 if len(in) == 0 {
906 return nil
907 }
908 out := make([]*skills.SkillState, len(in))
909 for i, s := range in {
910 state := &skills.SkillState{
911 Name: s.Name,
912 Path: s.Path,
913 State: skills.DiscoveryState(s.State),
914 }
915 if s.Error != "" {
916 state.Err = errors.New(s.Error)
917 }
918 out[i] = state
919 }
920 return out
921}
922
923func todosToProto(todos []session.Todo) []proto.Todo {
924 if len(todos) == 0 {
925 return nil
926 }
927 out := make([]proto.Todo, len(todos))
928 for i, t := range todos {
929 out[i] = proto.Todo{
930 Content: t.Content,
931 Status: string(t.Status),
932 ActiveForm: t.ActiveForm,
933 }
934 }
935 return out
936}