// Package codex brokers an operator chat through the Codex App Server. // // Codex exposes threads, turns and items over JSON-RPC. The App Server is // normally reached over a Unix WebSocket socket (the desktop app and the CLI use // the same control socket). This adapter owns one client connection and mirrors // the protocol into the Pipelines chat frames; it never starts a second Codex // daemon or changes the operator's Codex configuration. Installed servers use // a private connection host to retain pending interactions during restarts. package codex import ( "context" "encoding/json" "errors" "fmt" "net" "net/http" "net/url" "os" "path/filepath" "strconv" "strings" "sync" "time" "git.a-wan.net/alan/pipelines/internal/opencode" "git.a-wan.net/alan/pipelines/internal/protocol" "github.com/coder/websocket" ) // Backend is the wire value stored in the operator-session registry. const Backend = "codex" // DefaultSocketPath is the Codex desktop app-server control socket. func DefaultSocketPath() string { home := os.Getenv("CODEX_HOME") if home == "" { userHome, err := os.UserHomeDir() if err != nil { return "" } home = filepath.Join(userHome, ".codex") } return filepath.Join(home, "app-server-control", "app-server-control.sock") } // Chat is one owned App Server connection. type Chat struct { conn *websocket.Conn ctx context.Context cancel context.CancelFunc writeMu sync.Mutex nextID int64 mu sync.Mutex pending map[string]chan rpcResponse subs map[string]map[chan protocol.ChatEventFrame]struct{} forms map[string]pendingForm approvals map[string]pendingApproval commands map[string]map[string]commandSnapshot commandOrder uint64 starting map[string]bool turns map[string]string emitted map[string]bool closed bool connectionErr error compactions map[string]protocol.ChatEventFrame endedTurns map[string]string usage map[string]usageSnapshot usageOrder uint64 modes map[string]string // Thinking levels (efforts.go): the cached model catalog and each // thread's level for its next turn/start. models []catalogModel modelsAt time.Time efforts map[string]string // Account quota (quota.go): merged native snapshot and the read schedule. quota *quotaState accountReads bool accountReading bool accountReadAt time.Time } type pendingForm struct { requestID json.RawMessage threadID string form protocol.ChatForm answering bool elicitation bool } type rpcResponse struct { Result json.RawMessage Error *rpcError Transport bool } type rpcError struct { Code int `json:"code"` Message string `json:"message"` } type rpcCallError struct { Code int Message string } func (e *rpcCallError) Error() string { return e.Message } type rpcMessage struct { ID json.RawMessage `json:"id"` Method string `json:"method"` Params json.RawMessage `json:"params"` Result json.RawMessage `json:"result"` Error *rpcError `json:"error"` } // Open connects to the app-server socket and performs the initialize handshake. func Open(ctx context.Context) (*Chat, error) { socket := DefaultSocketPath() if socket == "" { return nil, errors.New("Codex home is unavailable") } var socketErr error socket, socketErr = connectionSocket(ctx, socket) if socketErr != nil { return nil, fmt.Errorf("attach Codex connection host: %w", socketErr) } transport := &http.Transport{ DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) { return (&net.Dialer{}).DialContext(ctx, "unix", socket) }, } client := &http.Client{Transport: transport} conn, _, err := websocket.Dial(ctx, "ws://localhost/", &websocket.DialOptions{HTTPClient: client}) if err != nil { return nil, fmt.Errorf("connect Codex app-server: %w", err) } conn.SetReadLimit(16 << 20) child, cancel := context.WithCancel(ctx) c := &Chat{ conn: conn, ctx: child, cancel: cancel, pending: map[string]chan rpcResponse{}, subs: map[string]map[chan protocol.ChatEventFrame]struct{}{}, forms: map[string]pendingForm{}, turns: map[string]string{}, emitted: map[string]bool{}, } go c.readLoop() initCtx, initCancel := context.WithTimeout(ctx, 10*time.Second) defer initCancel() if _, err := c.call(initCtx, "initialize", map[string]any{ "clientInfo": map[string]any{"name": "pipelines", "title": "Pipelines", "version": "0.1"}, }); err != nil { c.Close() return nil, fmt.Errorf("initialize Codex app-server: %w", err) } c.mu.Lock() c.accountReads = true c.mu.Unlock() c.readAccountRateLimits() return c, nil } // Available reports whether the app-server control socket exists. func Available() bool { path := DefaultSocketPath() if path == "" { return false } info, err := os.Stat(path) return err == nil && info.Mode()&os.ModeSocket != 0 } // Close shuts the owned client connection down. func (c *Chat) Close() { c.mu.Lock() if c.closed { c.mu.Unlock() return } c.closed = true c.usage = nil c.mu.Unlock() c.cancel() _ = c.conn.Close(websocket.StatusNormalClosure, "") } // Detach is the server-restart shutdown (chatShutdownDetacher): threads and their turns live // in the Codex App Server, not in this client, so closing the control // connection leaves them running; no turn is interrupted. The next server // process reconnects and reconciles each thread through thread/read. An // approval or question is retained by the configured connection host and // replayed on reattach. Direct mode cannot retain connection-bound callbacks. func (c *Chat) Detach() { c.Close() } func (c *Chat) readLoop() { for { _, data, err := c.conn.Read(c.ctx) if err != nil { c.failPending(err) return } var msg rpcMessage if err := json.Unmarshal(data, &msg); err != nil { continue } if len(msg.ID) > 0 && msg.Method != "" { c.handleServerRequest(msg) continue } if len(msg.ID) > 0 { key := string(msg.ID) c.mu.Lock() ch := c.pending[key] delete(c.pending, key) c.mu.Unlock() if ch != nil { ch <- rpcResponse{Result: msg.Result, Error: msg.Error} } continue } if msg.Method != "" { c.handleNotification(msg) } } } func (c *Chat) failPending(err error) { c.mu.Lock() c.compactions = nil c.usage = nil c.connectionErr = err c.approvals = nil c.forms = map[string]pendingForm{} pending := c.pending c.pending = map[string]chan rpcResponse{} subs := c.subs c.subs = map[string]map[chan protocol.ChatEventFrame]struct{}{} c.mu.Unlock() for _, ch := range pending { ch <- rpcResponse{Error: &rpcError{Message: err.Error()}, Transport: true} } for _, set := range subs { for ch := range set { close(ch) } } } func (c *Chat) call(ctx context.Context, method string, params any) (json.RawMessage, error) { c.mu.Lock() if c.closed { c.mu.Unlock() return nil, errors.New("Codex connection is closed") } c.nextID++ id := c.nextID ch := make(chan rpcResponse, 1) c.pending[strconv.FormatInt(id, 10)] = ch c.mu.Unlock() payload := map[string]any{"id": id, "method": method} if params != nil { payload["params"] = params } data, err := json.Marshal(payload) if err != nil { return nil, err } c.writeMu.Lock() err = c.conn.Write(ctx, websocket.MessageText, data) c.writeMu.Unlock() if err != nil { c.mu.Lock() delete(c.pending, strconv.FormatInt(id, 10)) c.mu.Unlock() return nil, err } select { case <-ctx.Done(): c.mu.Lock() delete(c.pending, strconv.FormatInt(id, 10)) c.mu.Unlock() return nil, ctx.Err() case resp := <-ch: if resp.Error != nil { if resp.Transport { return nil, errors.New(resp.Error.Message) } return nil, &rpcCallError{Code: resp.Error.Code, Message: resp.Error.Message} } return resp.Result, nil } } func (c *Chat) respond(id json.RawMessage, result any) { payload := map[string]any{"id": id, "result": result} data, err := json.Marshal(payload) if err != nil { return } c.writeMu.Lock() _ = c.conn.Write(c.ctx, websocket.MessageText, data) c.writeMu.Unlock() } func (c *Chat) emit(frame protocol.ChatEventFrame) { c.mu.Lock() if frame.Kind == protocol.ChatEventUsage && frame.Usage != nil { usage := *frame.Usage usage.Account = c.accountLocked() frame.Usage = &usage } if frame.Kind == protocol.ChatEventUsage && !c.retainUsageLocked(frame) { c.mu.Unlock() return } if frame.Kind == protocol.ChatEventCompaction { if frame.Compaction == nil { c.mu.Unlock() return } if frame.NativeTurnID != "" && c.endedTurns[frame.SessionID] == frame.NativeTurnID { c.mu.Unlock() return } if current := c.turns[frame.SessionID]; current != "" && frame.NativeTurnID != "" && current != frame.NativeTurnID { c.mu.Unlock() return } if frame.Compaction.Status == "running" { if c.compactions == nil { c.compactions = map[string]protocol.ChatEventFrame{} } c.compactions[frame.SessionID] = frame } else { previous := c.compactions[frame.SessionID] if previous.Compaction != nil && frame.Compaction.ID != "" && previous.Compaction.ID != frame.Compaction.ID { c.mu.Unlock() return } delete(c.compactions, frame.SessionID) } } if frame.Kind == protocol.ChatEventStep && frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded { delete(c.compactions, frame.SessionID) if frame.Step.TurnID != "" { if c.endedTurns == nil { c.endedTurns = map[string]string{} } c.endedTurns[frame.SessionID] = frame.Step.TurnID } } set := c.subs[frame.SessionID] var targets []chan protocol.ChatEventFrame for ch := range set { targets = append(targets, ch) } c.mu.Unlock() for _, ch := range targets { select { case ch <- frame: default: // A slow client must not block the shared Codex connection. The hub // will repair from history on its next subscription. } } } func (c *Chat) subscribe(id string) chan protocol.ChatEventFrame { ch := make(chan protocol.ChatEventFrame, 256) c.mu.Lock() if c.subs[id] == nil { c.subs[id] = map[chan protocol.ChatEventFrame]struct{}{} } c.subs[id][ch] = struct{}{} if snapshot, ok := c.usage[id]; ok { frame := snapshot.frame if frame.Usage != nil { usage := *frame.Usage usage.Account = c.accountLocked() frame.Usage = &usage } ch <- frame } else if account := c.accountLocked(); account != nil { ch <- protocol.ChatEventFrame{SessionID: id, Kind: protocol.ChatEventUsage, Usage: &protocol.ChatUsage{Account: account}} } if frame, ok := c.compactions[id]; ok { ch <- frame } c.mu.Unlock() c.readAccountRateLimits() return ch } func (c *Chat) unsubscribe(id string, ch chan protocol.ChatEventFrame) { c.mu.Lock() if set := c.subs[id]; set != nil { delete(set, ch) if len(set) == 0 { delete(c.subs, id) } } c.mu.Unlock() } // Stream exposes one thread's notifications as chat frames. func (c *Chat) Stream(ctx context.Context, id string, ready func(), emit func(protocol.ChatEventFrame) error) error { return c.streamWithReadback(ctx, id, ready, emit) } // Prompt starts one turn. The user turn is already broadcast by the server, so // the adapter only forwards the assistant's items. func (c *Chat) Prompt(ctx context.Context, id, text string) error { return c.PromptWithMessageID(ctx, id, text, "") } // PromptWithMessageID carries the client's native user-message id so the // optimistic browser bubble and the authoritative history item can reconcile. func (c *Chat) PromptWithMessageID(ctx context.Context, id, text, messageID string) error { return c.PromptWithMessageIDModel(ctx, id, text, messageID, "") } // PromptWithMessageIDModel applies a persisted per-chat choice at the explicit // next-turn boundary. It does not resume a thread or edit global configuration. func (c *Chat) PromptWithMessageIDModel(ctx context.Context, id, text, messageID, model string) error { return c.PromptWithMessageIDModelFiles(ctx, id, text, messageID, model, nil) } // PromptWithMessageIDFiles submits server-prepared attachments without changing // provider policy or configuration. func (c *Chat) PromptWithMessageIDFiles(ctx context.Context, id, text, messageID string, files []opencode.PromptFile) error { return c.PromptWithMessageIDModelFiles(ctx, id, text, messageID, "", files) } // PromptWithMessageIDModelFiles keeps attachment and model overrides on one turn. func (c *Chat) PromptWithMessageIDModelFiles(ctx context.Context, id, text, messageID, model string, files []opencode.PromptFile) error { input, err := promptInput(text, files) if err != nil { return err } params := map[string]any{ "threadId": id, "input": input, } if messageID != "" { params["clientUserMessageId"] = messageID } if model != "" { params["model"] = model } c.applyMode(id, params) c.applyEffort(id, params) c.mu.Lock() if c.starting == nil { c.starting = map[string]bool{} } c.starting[id] = true c.mu.Unlock() raw, err := c.call(ctx, "turn/start", params) // A read-only browser connection may point at a persisted, unloaded thread. // Only an explicit Send can load it. Retry solely after the provider's exact // application-level refusal: transport/timeout failures may have admitted a // turn and must never be blindly repeated. var refused *rpcCallError if errors.As(err, &refused) && refused.Message == "thread not found: "+id { var resumed json.RawMessage resumed, err = c.resumeThread(ctx, map[string]any{"threadId": id, "excludeTurns": true}, id) if err == nil { var response struct { Thread struct { ID string `json:"id"` } `json:"thread"` } if json.Unmarshal(resumed, &response) != nil || response.Thread.ID != id { err = errors.New("Codex did not confirm the requested thread was loaded") } else { raw, err = c.call(ctx, "turn/start", params) } } } var reply struct { Turn struct { ID string `json:"id"` } `json:"turn"` } if err == nil { _ = json.Unmarshal(raw, &reply) } c.mu.Lock() delete(c.starting, id) if reply.Turn.ID != "" { c.turns[id] = reply.Turn.ID } c.mu.Unlock() if err == nil && reply.Turn.ID != "" { c.emit(stepFrame(id, protocol.ChatStepStarted, reply.Turn.ID)) } return err } // SteerPrompt adds a user message to the thread's active turn with the App // Server's turn/steer, which the agent reads at its next step. expectedTurnId // pins the turn: when it already ended (or none is active) the App Server // refuses and false is returned so the caller queues the prompt for the next // turn instead. A transport failure is an error: it may have been admitted and // must not be blindly repeated. func (c *Chat) SteerPrompt(ctx context.Context, id, text, messageID string, files []opencode.PromptFile) (bool, error) { c.mu.Lock() turn := c.turns[id] c.mu.Unlock() if turn == "" { return false, nil } input, err := promptInput(text, files) if err != nil { return false, err } params := map[string]any{"threadId": id, "expectedTurnId": turn, "input": input} if messageID != "" { params["clientUserMessageId"] = messageID } _, err = c.call(ctx, "turn/steer", params) var refused *rpcCallError if errors.As(err, &refused) { return false, nil } if err != nil { return false, err } return true, nil } // ActivateSkill is an OpenCode-only chat concept. func (c *Chat) ActivateSkill(context.Context, string, string) error { return errors.New("Codex chat has no out-of-band skill activation") } // Interrupt cancels the thread's active turn. func (c *Chat) Interrupt(ctx context.Context, id string) error { c.mu.Lock() turn := c.turns[id] c.mu.Unlock() if turn == "" { return nil } _, err := c.call(ctx, "turn/interrupt", map[string]any{"threadId": id, "turnId": turn}) return err } // Create starts one Codex thread in directory. func (c *Chat) Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) { if strings.TrimSpace(directory) == "" { return protocol.ChatSession{}, errors.New("a directory is required") } raw, err := c.startThread(ctx, map[string]any{ "cwd": directory, "sandbox": "workspace-write", }) if err != nil { return protocol.ChatSession{}, err } var result struct { Thread thread `json:"thread"` Model string `json:"model"` ModelProvider string `json:"modelProvider"` } if err := json.Unmarshal(raw, &result); err != nil { return protocol.ChatSession{}, err } session := result.Thread.chatSession() if session.Model == "" { session.Model = result.Model } if session.ModelProvider == "" { session.ModelProvider = result.ModelProvider } session.Backend = Backend if strings.TrimSpace(title) != "" { session.Title = strings.TrimSpace(title) } if title != "" { _, _ = c.call(ctx, "thread/name/set", map[string]any{"threadId": session.ID, "name": title}) } return session, nil } // Session returns one thread's current record. func (c *Chat) Session(ctx context.Context, id string) (protocol.ChatSession, bool, error) { raw, err := c.call(ctx, "thread/read", map[string]any{"threadId": id}) if err != nil { return protocol.ChatSession{}, false, err } var result struct { Thread thread `json:"thread"` } if err := json.Unmarshal(raw, &result); err != nil { return protocol.ChatSession{}, false, err } if result.Thread.ID == "" { return protocol.ChatSession{}, false, nil } session := result.Thread.chatSession() session.Backend = Backend return session, true, nil } // Sessions lists Codex threads (bounded) so the server can intersect them with // the operator registry. func (c *Chat) Sessions(ctx context.Context) ([]protocol.ChatSession, error) { raw, err := c.call(ctx, "thread/list", map[string]any{"limit": 200}) if err != nil { return nil, err } var result struct { Data []thread `json:"data"` } if err := json.Unmarshal(raw, &result); err != nil { return nil, err } sessions := make([]protocol.ChatSession, 0, len(result.Data)) for _, t := range result.Data { session := t.chatSession() session.Backend = Backend sessions = append(sessions, session) } return sessions, nil } // Messages reads a thread's turns and flattens them into chat messages. func (c *Chat) Messages(ctx context.Context, id string, limit int, cursor string) (protocol.ChatHistoryPage, error) { if limit <= 0 { limit = 50 } if limit > 100 { limit = 100 } params := map[string]any{"threadId": id, "limit": limit, "sortDirection": "desc", "itemsView": "full"} if cursor != "" { params["cursor"] = cursor } raw, err := c.call(ctx, "thread/turns/list", params) if err != nil { return protocol.ChatHistoryPage{}, err } var result struct { Data []turn `json:"data"` NextCursor *string `json:"nextCursor"` } if err := json.Unmarshal(raw, &result); err != nil { return protocol.ChatHistoryPage{}, err } if result.Data == nil { return protocol.ChatHistoryPage{}, errors.New("invalid Codex history page") } messages := []protocol.ChatMessage{} for index := len(result.Data) - 1; index >= 0; index-- { turn := result.Data[index] for _, item := range turn.Items { if msg, ok := item.chatMessage(id); ok { msg.CreatedAt = turn.createdAtMillis() messages = append(messages, msg) } } if turn.ID != "" && rawText(turn.Error) != "" { part := item{ID: turn.ID + "#error", Type: "Codex turn", Status: "failed", Error: turn.Error, Input: map[string]any{"turn_id": turn.ID}}.toolPart(true) messages = append(messages, protocol.ChatMessage{ID: part.ID, SessionID: id, Role: protocol.ChatRoleAssistant, CreatedAt: turn.createdAtMillis(), Parts: []protocol.ChatPart{part}}) } } page := protocol.ChatHistoryPage{Messages: messages} if result.NextCursor != nil { page.NextCursor = *result.NextCursor page.HasMore = page.NextCursor != "" } return page, nil } // Answer replies to a pending requestUserInput request. func (c *Chat) Answer(ctx context.Context, request protocol.ChatAnswerRequest) error { if request.Action != "" && request.Action != "accept" && request.Action != "cancel" && request.Action != "decline" { return errors.New("invalid form action") } c.mu.Lock() pending, ok := c.forms[request.FormID] if request.Action != "" && request.Action != "accept" && (!ok || !pending.elicitation) { c.mu.Unlock() return errors.New("this Codex question does not support that action") } if ok && pending.threadID == request.SessionID && !pending.answering { pending.answering = true c.forms[request.FormID] = pending } else { ok = false } c.mu.Unlock() if !ok { return errors.New("the Codex question is no longer awaiting an answer") } answers := map[string]any{} for key, value := range request.Answers { switch v := value.(type) { case []any: answers[key] = map[string]any{"answers": v} case []string: answers[key] = map[string]any{"answers": v} case string: answers[key] = map[string]any{"answers": []string{v}} default: answers[key] = map[string]any{"answers": []string{fmt.Sprint(v)}} } } var result any = map[string]any{"answers": answers} if pending.elicitation { action := request.Action if action == "" { action = "accept" } var content any = request.Answers if action != "accept" || pending.form.Kind == "elicitation-url" { content = nil } result = map[string]any{"action": action, "content": content, "_meta": nil} } err := c.respondResult(ctx, pending.requestID, result) c.mu.Lock() if err == nil { delete(c.forms, request.FormID) } else if _, exists := c.forms[request.FormID]; exists { pending.answering = false c.forms[request.FormID] = pending } c.mu.Unlock() if err != nil { return err } c.emit(protocol.ChatEventFrame{ SessionID: pending.threadID, Kind: protocol.ChatEventForm, Form: &protocol.ChatForm{ID: pending.form.ID, SessionID: pending.threadID, Resolved: true}, }) return nil } func (c *Chat) handleServerRequest(msg rpcMessage) { switch msg.Method { case "item/tool/requestUserInput": var params struct { ThreadID string `json:"threadId"` TurnID string `json:"turnId"` ItemID string `json:"itemId"` Questions []struct { ID string `json:"id"` Header string `json:"header"` Question string `json:"question"` IsOther bool `json:"isOther"` IsSecret bool `json:"isSecret"` Options []struct { Value string `json:"value"` Label string `json:"label"` Description string `json:"description"` } `json:"options"` } `json:"questions"` } if err := json.Unmarshal(msg.Params, ¶ms); err != nil || params.ThreadID == "" || params.ItemID == "" { c.respond(msg.ID, map[string]any{"answers": map[string]any{}}) return } form := protocol.ChatForm{ ID: params.ItemID, SessionID: params.ThreadID, Title: "Question", Kind: "question", } for _, q := range params.Questions { field := protocol.ChatFormField{ Key: q.ID, Title: q.Question, Description: q.Header, Type: "string", Custom: q.IsOther, Required: true, Secret: q.IsSecret, } for _, option := range q.Options { value := option.Value if value == "" { value = option.Label } field.Options = append(field.Options, protocol.ChatFormOption{ Value: value, Label: option.Label, Description: option.Description, }) } form.Fields = append(form.Fields, field) } c.mu.Lock() c.forms[form.ID] = pendingForm{requestID: msg.ID, threadID: params.ThreadID, form: form} c.mu.Unlock() c.emit(protocol.ChatEventFrame{SessionID: params.ThreadID, Kind: protocol.ChatEventForm, Form: &form}) case "item/commandExecution/requestApproval", "item/fileChange/requestApproval", "item/permissions/requestApproval": c.receiveApproval(msg) case "mcpServer/elicitation/request": c.receiveElicitation(msg) default: // Unknown server requests must not stall the shared connection. c.respondUnsupported(msg.ID) } } func (c *Chat) handleNotification(msg rpcMessage) { if msg.Method == "thread/tokenUsage/updated" { c.receiveUsage(msg.Params) return } if msg.Method == "account/rateLimits/updated" { c.receiveRateLimits(msg.Params) return } if msg.Method == "serverRequest/resolved" { var p struct { ThreadID string `json:"threadId"` RequestID json.RawMessage `json:"requestId"` } if json.Unmarshal(msg.Params, &p) == nil && p.ThreadID != "" && len(p.RequestID) > 0 { c.resolveInteraction(p.ThreadID, p.RequestID) } return } var params struct { StartedAtMS int64 `json:"startedAtMs"` CompletedAtMS int64 `json:"completedAtMs"` ThreadID string `json:"threadId"` TurnID string `json:"turnId"` ItemID string `json:"itemId"` Delta string `json:"delta"` Item json.RawMessage `json:"item"` Turn struct { ID string `json:"id"` Status string `json:"status"` } `json:"turn"` Status struct { Type string `json:"type"` } `json:"status"` } if err := json.Unmarshal(msg.Params, ¶ms); err != nil || params.ThreadID == "" { return } switch msg.Method { case "turn/started": c.mu.Lock() c.turns[params.ThreadID] = params.TurnID if c.turns[params.ThreadID] == "" { c.turns[params.ThreadID] = params.Turn.ID } nativeID := c.turns[params.ThreadID] c.mu.Unlock() c.emit(stepFrame(params.ThreadID, "started", nativeID)) case "turn/completed": completedID := params.TurnID if completedID == "" { completedID = params.Turn.ID } if completedID == "" { return } c.mu.Lock() if current := c.turns[params.ThreadID]; current != "" && current != completedID { c.mu.Unlock() return } delete(c.turns, params.ThreadID) c.mu.Unlock() c.emit(stepFrame(params.ThreadID, protocol.ChatStepEnded, completedID)) case "item/started": c.handleTimedItem(params.ThreadID, params.ItemID, params.Item, false, params.StartedAtMS, 0, params.TurnID) case "item/completed": c.handleTimedItem(params.ThreadID, params.ItemID, params.Item, true, 0, params.CompletedAtMS, params.TurnID) case "thread/compacted": // Deprecated ContextCompactedNotification has only threadId/turnId. // Modern item lifecycles are correlated more precisely; never let this // unkeyed legacy duplicate clear a newer modern compaction item. c.mu.Lock() modern := c.compactions[params.ThreadID].Compaction != nil c.mu.Unlock() if !modern { c.emit(protocol.ChatEventFrame{SessionID: params.ThreadID, NativeTurnID: params.TurnID, Kind: protocol.ChatEventCompaction, Compaction: &protocol.ChatCompaction{Status: "completed"}}) } case "item/agentMessage/delta", "item/agentMessage/streaming": if params.ItemID != "" && params.Delta != "" { c.markEmitted(params.ItemID) c.emit(textFrame(params.ThreadID, params.ItemID, protocol.ChatEventText, params.Delta)) } case "item/reasoning/delta": if params.ItemID != "" && params.Delta != "" { c.markEmitted(params.ItemID) c.emit(textFrame(params.ThreadID, params.ItemID, protocol.ChatEventReasoning, params.Delta)) } case "item/commandExecution/outputDelta": c.commandDelta(params.ThreadID, params.ItemID, params.Delta) } } func (c *Chat) handleItem(threadID, itemID string, raw json.RawMessage, completed bool, nativeTurnID ...string) { c.handleTimedItem(threadID, itemID, raw, completed, 0, 0, nativeTurnID...) } func (c *Chat) handleTimedItem(threadID, itemID string, raw json.RawMessage, completed bool, startedAt, completedAt int64, nativeTurnID ...string) { var record item if err := json.Unmarshal(raw, &record); err != nil { return } if record.ID == "" { record.ID = itemID } record.startedAtMS, record.completedAtMS = startedAt, completedAt switch record.Type { case "contextCompaction": if record.ID == "" { return } status := "running" if completed { status = "completed" } frame := protocol.ChatEventFrame{SessionID: threadID, Kind: protocol.ChatEventCompaction, Compaction: &protocol.ChatCompaction{Status: status, ID: record.ID}} if len(nativeTurnID) > 0 { frame.NativeTurnID = nativeTurnID[0] } c.emit(frame) case "agentMessage": if completed && record.Text != "" && !c.wasEmitted(record.ID) { c.emit(textFrame(threadID, record.ID, protocol.ChatEventText, record.Text)) } case "reasoning": text := record.reasoningText() if completed && text != "" && !c.wasEmitted(record.ID) { c.emit(textFrame(threadID, record.ID, protocol.ChatEventReasoning, text)) } case "userMessage": return default: if record.Type == "commandExecution" { c.recordCommand(threadID, record, true) } part := record.toolPart(completed) c.emit(protocol.ChatEventFrame{ SessionID: threadID, MessageID: record.ID, Kind: protocol.ChatEventTool, Part: &part, }) } } func (c *Chat) markEmitted(id string) { c.mu.Lock() c.emitted[id] = true c.mu.Unlock() } func (c *Chat) wasEmitted(id string) bool { c.mu.Lock() defer c.mu.Unlock() return c.emitted[id] } func textFrame(threadID, itemID, kind, delta string) protocol.ChatEventFrame { return protocol.ChatEventFrame{ SessionID: threadID, MessageID: itemID, Kind: kind, Delta: delta, Part: &protocol.ChatPart{Type: kind, ID: protocol.ChatDeltaPartID(itemID, kind, 0)}, } } func stepFrame(threadID, status string, nativeID ...string) protocol.ChatEventFrame { step := &protocol.ChatStep{Status: status} if len(nativeID) > 0 { step.TurnID = nativeID[0] } return protocol.ChatEventFrame{ SessionID: threadID, Kind: protocol.ChatEventStep, Step: step, } } type thread struct { Model string `json:"model"` ModelProvider string `json:"modelProvider"` ID string `json:"id"` Name string `json:"name"` Preview string `json:"preview"` Cwd string `json:"cwd"` CreatedAt int64 `json:"createdAt"` UpdatedAt int64 `json:"updatedAt"` Turns []turn `json:"turns"` // ReasoningEffort is the thread's own current thinking level. ReasoningEffort string `json:"reasoningEffort"` } type turn struct { StartedAt int64 `json:"startedAt"` ID string `json:"id"` Status string `json:"status"` Error json.RawMessage `json:"error"` Items []item `json:"items"` } // Codex history exposes a recorded turn start in seconds, rather than item // creation times. Use that shared turn time for its user and assistant rows. // Older history without timing remains unknown; never substitute read time. func (t turn) createdAtMillis() int64 { if t.StartedAt <= 0 || t.StartedAt > 8640000000000 { return 0 } return t.StartedAt * 1000 } type item struct { startedAtMS int64 completedAtMS int64 Raw json.RawMessage `json:"-"` ID string `json:"id"` ClientID string `json:"clientId"` Type string `json:"type"` Text string `json:"text"` Content json.RawMessage `json:"content"` Status string `json:"status"` Command string `json:"command"` Query string `json:"query"` Name string `json:"name"` Input any `json:"input"` Error json.RawMessage `json:"error"` Arguments json.RawMessage `json:"arguments"` Result json.RawMessage `json:"result"` Output json.RawMessage `json:"output"` ContentItems json.RawMessage `json:"contentItems"` Changes json.RawMessage `json:"changes"` Tool string `json:"tool"` Namespace string `json:"namespace"` Server string `json:"server"` AggregatedOutput string `json:"aggregatedOutput"` ExitCode *int `json:"exitCode"` DurationMS *int64 `json:"durationMs"` Summary []string `json:"summary"` } func (t thread) chatSession() protocol.ChatSession { title := strings.TrimSpace(t.Name) if title == "" { title = strings.TrimSpace(t.Preview) } return protocol.ChatSession{ ID: t.ID, Title: title, Directory: t.Cwd, Model: t.Model, ModelProvider: t.ModelProvider, Effort: t.ReasoningEffort, CreatedAt: t.CreatedAt * 1000, UpdatedAt: t.UpdatedAt * 1000, } } func (i item) chatMessage(sessionID string) (protocol.ChatMessage, bool) { msg := protocol.ChatMessage{ID: i.ID, SessionID: sessionID} switch i.Type { case "contextCompaction": // Historical ThreadItem has no lifecycle status. It is neither a // synthetic tool nor evidence that compaction is currently running. return protocol.ChatMessage{}, false case "userMessage": msg.Role = protocol.ChatRoleUser if i.ClientID != "" { msg.ID = i.ClientID } var content []struct { Type string `json:"type"` Text string `json:"text"` Name string `json:"name"` Path string `json:"path"` URL string `json:"url"` } _ = json.Unmarshal(i.Content, &content) for _, part := range content { if part.Type == "text" && part.Text != "" { msg.Parts = append(msg.Parts, protocol.ChatPart{Type: protocol.ChatPartText, Text: part.Text}) } else if (part.Type == "mention" || part.Type == "localImage") && filepath.IsAbs(part.Path) { name := part.Name if name == "" { name = filepath.Base(part.Path) } msg.Parts = append(msg.Parts, protocol.ChatPart{Type: protocol.ChatPartFile, Name: name, URI: (&url.URL{Scheme: "file", Path: part.Path}).String()}) } else if part.Type == "image" && part.URL != "" { msg.Parts = append(msg.Parts, protocol.ChatPart{Type: protocol.ChatPartFile, Name: "image", URI: part.URL}) } } case "agentMessage": msg.Role = protocol.ChatRoleAssistant if i.Text != "" { msg.Parts = append(msg.Parts, protocol.ChatPart{Type: protocol.ChatPartText, Text: i.Text}) } case "reasoning": msg.Role = protocol.ChatRoleAssistant if text := i.reasoningText(); text != "" { msg.Parts = append(msg.Parts, protocol.ChatPart{Type: protocol.ChatPartReasoning, Text: text}) } default: msg.Role = protocol.ChatRoleAssistant msg.Parts = []protocol.ChatPart{i.toolPart(!strings.EqualFold(i.Status, "inProgress"))} } return msg, len(msg.Parts) > 0 }