3eff8fa · crush · git.iko.soy

119 m.handleChildSession(event)

120 return nil

121 }

122−

122+

123 if m.messageExists(event.Payload.ID) {

124 return nil

125 }

126−

126+

127 return m.handleNewMessage(event.Payload)

128 case pubsub.UpdatedEvent:

129 return m.handleUpdateAssistantMessage(event.Payload)

192func (m *messageListCmp) handleUpdateAssistantMessage(msg message.Message) tea.Cmd {

193 var cmds []tea.Cmd

194 items := m.listCmp.Items()

195−

195+

196 // Find existing assistant message and tool calls for this message

197 assistantIndex, existingToolCalls := m.findAssistantMessageAndToolCalls(items, msg.ID)

198−

198+

199 logging.Info("Update Assistant Message", "msg", msg, "assistantMessageInx", assistantIndex, "toolCalls", existingToolCalls)

200−

200+

201 // Handle assistant message content

202 if cmd := m.updateAssistantMessageContent(msg, assistantIndex); cmd != nil {

203 cmds = append(cmds, cmd)

204 }

205−

205+

206 // Handle tool calls

207 if cmd := m.updateToolCalls(msg, existingToolCalls); cmd != nil {

208 cmds = append(cmds, cmd)

209 }

210−

210+

211 return tea.Batch(cmds...)

212}

213

215func (m *messageListCmp) findAssistantMessageAndToolCalls(items []util.Model, messageID string) (int, map[int]messages.ToolCallCmp) {

216 assistantIndex := NotFound

217 toolCalls := make(map[int]messages.ToolCallCmp)

218−

218+

219 // Search backwards as messages are more likely to be at the end

220 for i := len(items) - 1; i >= 0; i-- {

221 item := items[i]

229 }

230 }

231 }

232−

232+

233 return assistantIndex, toolCalls

234}

235

238 if assistantIndex == NotFound {

239 return nil

240 }

241−

241+

242 shouldShowMessage := m.shouldShowAssistantMessage(msg)

243 hasToolCallsOnly := len(msg.ToolCalls()) > 0 && msg.Content().Text == ""

244−

244+

245 if shouldShowMessage {

246 m.listCmp.UpdateItem(

247 assistantIndex,

253 } else if hasToolCallsOnly {

254 m.listCmp.DeleteItem(assistantIndex)

255 }

256−

256+

257 return nil

258}

259

265// updateToolCalls handles updates to tool calls, updating existing ones and adding new ones.

266func (m *messageListCmp) updateToolCalls(msg message.Message, existingToolCalls map[int]messages.ToolCallCmp) tea.Cmd {

267 var cmds []tea.Cmd

268−

268+

269 for _, tc := range msg.ToolCalls() {

270 if cmd := m.updateOrAddToolCall(tc, existingToolCalls, msg.ID); cmd != nil {

271 cmds = append(cmds, cmd)

272 }

273 }

274−

274+

275 return tea.Batch(cmds...)

276}

277

285 return nil

286 }

287 }

288−

288+

289 // Add new tool call if not found

290 return m.listCmp.AppendItem(messages.NewToolCallCmp(messageID, tc))

291}

293// handleNewAssistantMessage processes new assistant messages and their tool calls.

294func (m *messageListCmp) handleNewAssistantMessage(msg message.Message) tea.Cmd {

295 var cmds []tea.Cmd

296−

296+

297 // Add assistant message if it should be displayed

298 if m.shouldShowAssistantMessage(msg) {

299 cmd := m.listCmp.AppendItem(

304 )

305 cmds = append(cmds, cmd)

306 }

307−

307+

308 // Add tool calls

309 for _, tc := range msg.ToolCalls() {

310 cmd := m.listCmp.AppendItem(messages.NewToolCallCmp(msg.ID, tc))

311 cmds = append(cmds, cmd)

312 }

313−

313+

314 return tea.Batch(cmds...)

315}

316

319 if m.session.ID == session.ID {

320 return nil

321 }

322−

322+

323 m.session = session

324 sessionMessages, err := m.app.Messages.List(context.Background(), session.ID)

325 if err != nil {

326 return util.ReportError(err)

327 }

328−

328+

329 if len(sessionMessages) == 0 {

330 return m.listCmp.SetItems([]util.Model{})

331 }

332−

332+

333 // Initialize with first message timestamp

334 m.lastUserMessageTime = sessionMessages[0].CreatedAt

335−

335+

336 // Build tool result map for efficient lookup

337 toolResultMap := m.buildToolResultMap(sessionMessages)

338−

338+

339 // Convert messages to UI components

340 uiMessages := m.convertMessagesToUI(sessionMessages, toolResultMap)

341−

341+

342 return m.listCmp.SetItems(uiMessages)

343}

344

356// convertMessagesToUI converts database messages to UI components.

357func (m *messageListCmp) convertMessagesToUI(sessionMessages []message.Message, toolResultMap map[string]message.ToolResult) []util.Model {

358 uiMessages := make([]util.Model, 0)

359−

359+

360 for _, msg := range sessionMessages {

361 switch msg.Role {

362 case message.User:

366 uiMessages = append(uiMessages, m.convertAssistantMessage(msg, toolResultMap)...)

367 }

368 }

369−

369+

370 return uiMessages

371}

372

373// convertAssistantMessage converts an assistant message and its tool calls to UI components.

374func (m *messageListCmp) convertAssistantMessage(msg message.Message, toolResultMap map[string]message.ToolResult) []util.Model {

375 var uiMessages []util.Model

376−

376+

377 // Add assistant message if it should be displayed

378 if m.shouldShowAssistantMessage(msg) {

379 uiMessages = append(

384 ),

385 )

386 }

387−

387+

388 // Add tool calls with their results and status

389 for _, tc := range msg.ToolCalls() {

390 options := m.buildToolCallOptions(tc, msg, toolResultMap)

391 uiMessages = append(uiMessages, messages.NewToolCallCmp(msg.ID, tc, options...))

392 }

393−

393+

394 return uiMessages

395}

396

397// buildToolCallOptions creates options for tool call components based on results and status.

398func (m *messageListCmp) buildToolCallOptions(tc message.ToolCall, msg message.Message, toolResultMap map[string]message.ToolResult) []messages.ToolCallOption {

399 var options []messages.ToolCallOption

400−

400+

401 // Add tool result if available

402 if tr, ok := toolResultMap[tc.ID]; ok {

403 options = append(options, messages.WithToolCallResult(tr))

404 }

405−

405+

406 // Add cancelled status if applicable

407 if msg.FinishPart() != nil && msg.FinishPart().Reason == message.FinishReasonCanceled {

408 options = append(options, messages.WithToolCallCancelled())

409 }

410−

410+

411 return options

412}

413