refactor(tui): extract attachments from document parts in session

pkg/app/app.go

@@ -488,8 +488,35 @@ func (a *App) Run(ctx context.Context, cancel context.CancelFunc, message string
 				case att.Content != "":
 					// Inline content attachment (e.g. pasted text).
 					a.processInlineAttachment(att, &textBuilder)
+				case len(att.Data) > 0:
+					// Binary inline content.
+					doc, resizeMeta, procErr := chat.ProcessAttachmentWithMetadata(chat.MessagePart{
+						Type: chat.MessagePartTypeDocument,
+						Document: &chat.Document{
+							Name:     att.Name,
+							MimeType: att.MimeType,
+							Source: chat.DocumentSource{
+								InlineData: att.Data,
+							},
+						},
+					})
+					if procErr != nil {
+						slog.WarnContext(ctx, "skipping inline attachment: processing failed", "name", att.Name, "error", procErr)
+						a.sendEvent(ctx, runtime.Warning(fmt.Sprintf("Skipped attachment %s: %s", att.Name, procErr), ""))
+						continue
+					}
+					if resizeMeta != nil {
+						if note := chat.FormatDimensionNote(resizeMeta); note != "" {
+							textBuilder.WriteString("\n")
+							textBuilder.WriteString(note)
+						}
+					}
+					binaryParts = append(binaryParts, chat.MessagePart{
+						Type:     chat.MessagePartTypeDocument,
+						Document: &doc,
+					})
 				default:
-					slog.DebugContext(ctx, "skipping attachment with no file path or content", "name", att.Name)
+					slog.DebugContext(ctx, "skipping attachment with no file path, content, or data", "name", att.Name)
 				}
 			}
 
@@ -599,7 +626,8 @@ func (a *App) processFileAttachment(ctx context.Context, att messages.Attachment
 		// For images, emit a dimension note so the model can map coordinates back to the original.
 		if resizeMeta != nil {
 			if note := chat.FormatDimensionNote(resizeMeta); note != "" {
-				textBuilder.WriteString("\n" + note)
+				textBuilder.WriteString("\n")
+				textBuilder.WriteString(note)
 			}
 		}
 		*binaryParts = append(*binaryParts, chat.MessagePart{

pkg/tui/messages/session.go

@@ -18,6 +18,10 @@ type Attachment struct {
 	// backing temp file is cleaned up before the message reaches the app layer.
 	// Empty for file-reference attachments that are read from disk.
 	Content string
+	// MimeType is the MIME type of the binary data, if Data is present.
+	MimeType string
+	// Data holds raw binary content for non-text inline attachments.
+	Data []byte
 }
 
 // Session lifecycle messages control session state and persistence.

pkg/tui/page/chat/chat.go

@@ -785,8 +785,8 @@ func (p *chatPage) handleInlineEditCancelled(msg messages.InlineEditCancelledMsg
 }
 
 // extractAttachmentsFromSession extracts attachments from a session message at the given position.
-// Attachments are stored as text parts in MultiContent with format "Contents of <filename>: <dataURL>".
-// TODO(krisetto): meh we can store and retrieve attachments better in the session itself
+// Legacy attachments are stored as text parts in MultiContent with format "Contents of <filename>: <dataURL>".
+// New attachments are stored as Document parts.
 func (p *chatPage) extractAttachmentsFromSession(position int) []msgtypes.Attachment {
 	sess := p.app.Session()
 	if sess == nil || position < 0 || position >= len(sess.Messages) {
@@ -805,20 +805,37 @@ func (p *chatPage) extractAttachmentsFromSession(position int) []msgtypes.Attach
 	}
 
 	var attachments []msgtypes.Attachment
-	const prefix = "Contents of "
+	const legacyPrefix = "Contents of "
 
 	// Skip the first part (main text content), look for attachment parts
 	for i := 1; i < len(msg.MultiContent); i++ {
 		part := msg.MultiContent[i]
+
+		if part.Type == chat.MessagePartTypeDocument && part.Document != nil {
+			content := part.Document.Source.InlineText
+			data := part.Document.Source.InlineData
+			mimeType := part.Document.MimeType
+
+			if content != "" || len(data) > 0 {
+				attachments = append(attachments, msgtypes.Attachment{
+					Name:     part.Document.Name,
+					Content:  content,
+					MimeType: mimeType,
+					Data:     data,
+				})
+			}
+			continue
+		}
+
 		if part.Type != chat.MessagePartTypeText {
 			continue
 		}
 		text := part.Text
-		if !strings.HasPrefix(text, prefix) {
+		if !strings.HasPrefix(text, legacyPrefix) {
 			continue
 		}
 		// Parse "Contents of <filename>: <dataURL>"
-		rest := text[len(prefix):]
+		rest := text[len(legacyPrefix):]
 		before, after, ok := strings.Cut(rest, ": ")
 		if !ok {
 			continue