feat: store absolute attachment paths in message content for AI context

## Summary
Enables text-based AI models to reference images and other attachments
from previous generations by storing absolute file paths as hidden markers
in the message content. This allows seamless multi-model conversations where
image-generating models (DALL-E, Flux) can pass their output to text models.

## Changes

### Backend Changes
- Add `getBasePath()` IPC handler to expose attachment storage directory path
- Update `AttachmentStorage` constructor documentation to clarify Electron
  userData paths across platforms (macOS, Windows, Linux)

### Frontend State Management
- Modify `persistMessage()` to generate content markers when messages have
  attachments but no text content
- Format: `[attachment:type:/absolute/path:filename]`
- Implement absolute path resolution via IPC to `attachmentStorage.getBasePath()`
- Return generated content from `persistMessage()` for UI synchronization
- Track generated content separately to avoid duplicating in state

### UI Rendering
- Filter attachment markers from visible content in `Response` component
  so users don't see the internal markers
- Support both new format `[attachment:...]` and old markdown format
  `![...](levante://attachments/...)`
- Preserve message rendering when content is only attachment markers

### Message State Synchronization
- Update `ChatPage.tsx` to capture generated content from `persistMessage()`
- Add generated content to message `parts` array for inclusion in AI context
- Ensure message state stays in sync with persisted content

## Technical Details
- Attachment markers are invisible to end users but included in AI context
- Absolute paths ensure models can locate files regardless of session
- Backward compatible with existing messages and old markdown format
- All changes preserve type safety with proper TypeScript updates

## Migration
- Script updated to use correct Electron userData path
  - Previous: ~/levante/attachments/
  - Correct: ~/Library/Application Support/Levante/attachments/ (macOS)

Author: Alejandro Gómez Cerezo

src/main/ipc/attachmentHandlers.ts

@@ -164,5 +164,14 @@ export function setupAttachmentHandlers() {
     }
   });
 
+  // Get base path for attachments
+  ipcMain.removeHandler('levante/attachments/base-path');
+  ipcMain.handle('levante/attachments/base-path', () => {
+    return {
+      success: true,
+      data: attachmentStorage.getBasePath()
+    };
+  });
+
   logger.ipc.info('Attachment IPC handlers registered');
 }

src/main/services/attachmentStorage.ts

@@ -23,7 +23,10 @@ export class AttachmentStorage {
   private baseDir: string;
 
   constructor() {
-    // Store attachments in user data directory: ~/levante/attachments/
+    // Store attachments in Electron userData directory
+    // macOS: ~/Library/Application Support/Levante/attachments/
+    // Windows: %APPDATA%/Levante/attachments/
+    // Linux: ~/.config/Levante/attachments/
     const userData = app.getPath('userData');
     this.baseDir = path.join(userData, 'attachments');
     this.ensureBaseDirExists();

src/preload/api/attachments.ts

@@ -49,4 +49,9 @@ export const attachmentsApi = {
    * Get storage statistics
    */
   stats: () => ipcRenderer.invoke('levante/attachments/stats'),
+
+  /**
+   * Get base path for attachments storage
+   */
+  getBasePath: () => ipcRenderer.invoke('levante/attachments/base-path'),
 };

src/preload/preload.ts

@@ -577,6 +577,11 @@ export interface LevanteAPI {
       data?: { totalSize: number; fileCount: number };
       error?: string;
     }>;
+    getBasePath: () => Promise<{
+      success: boolean;
+      data?: string;
+      error?: string;
+    }>;
   };
 
   // Analytics functionality

src/renderer/components/ai-elements/response.tsx

@@ -71,21 +71,41 @@ const processContentWithMermaid = (content: string) => {
   return parts.length > 1 ? parts : [{ type: 'text', content }];
 };
 
+// Filter out attachment markers from content (they're for AI context only)
+const filterAttachmentMarkers = (content: string): string => {
+  return content
+    // New format: [attachment:type:path:filename]
+    .replace(/\[attachment:[^\]]+\]\n?/g, '')
+    // Old format: ![filename](levante://attachments/...)
+    .replace(/!\[[^\]]*\]\(levante:\/\/attachments\/[^)]*\)\n?/g, '')
+    .trim();
+};
+
 export const Response = memo(
   ({ className, children, ...props }: ResponseProps) => {
     const [shouldProcessMermaid, setShouldProcessMermaid] = useState(false);
     const { streamFinished } = useStreamingContext();
     // Streamdown expects [lightTheme, darkTheme] tuple
     const shikiTheme: [BundledTheme, BundledTheme] = ['github-light', 'github-dark'];
 
+    // Filter attachment markers from string content
+    const filteredChildren = typeof children === 'string'
+      ? filterAttachmentMarkers(children)
+      : children;
+
     // Listen for streaming finish events
     useEffect(() => {
-      if (typeof children === 'string' && children.includes('```mermaid')) {
+      if (typeof filteredChildren === 'string' && filteredChildren.includes('```mermaid')) {
         setShouldProcessMermaid(true);
       }
-    }, [streamFinished, children]);
+    }, [streamFinished, filteredChildren]);
+
+    // Don't render anything if content is only attachment markers
+    if (typeof filteredChildren === 'string' && !filteredChildren) {
+      return null;
+    }
 
-    if (typeof children !== 'string') {
+    if (typeof filteredChildren !== 'string') {
       return (
         <Streamdown
           className={cn(
@@ -98,17 +118,17 @@ export const Response = memo(
           shikiTheme={shikiTheme}
           {...props}
         >
-          {children}
+          {filteredChildren}
         </Streamdown>
       );
     }
 
     // Check if content has complete mermaid blocks
-    const hasCompleteMermaid = /```mermaid\s*\n[\s\S]*?\n\s*```/.test(children);
+    const hasCompleteMermaid = /```mermaid\s*\n[\s\S]*?\n\s*```/.test(filteredChildren);
 
     // If we should process Mermaid and have complete blocks, do so
     if (shouldProcessMermaid && hasCompleteMermaid) {
-      const parts = processContentWithMermaid(children);
+      const parts = processContentWithMermaid(filteredChildren);
 
       if (parts.length > 1 || (parts.length === 1 && parts[0].type === 'mermaid')) {
         return (
@@ -150,7 +170,7 @@ export const Response = memo(
         shikiTheme={shikiTheme}
         {...props}
       >
-        {children}
+        {filteredChildren}
       </Streamdown>
     );
   }

src/renderer/pages/ChatPage.tsx

@@ -266,22 +266,42 @@ const ChatPage = () => {
           attachments: messageWithAttachments.attachments,
         });
 
-        await persistMessage(messageWithAttachments);
+        const persistResult = await persistMessage(messageWithAttachments);
 
-        // Update the message in useChat state to include attachments
+        // Update the message in useChat state to include attachments and generated content
         if (generatedAttachments.length > 0) {
           logger.core.info('Updating message state with attachments', {
             messageId: message.id,
             attachmentCount: generatedAttachments.length,
+            hasGeneratedContent: !!persistResult?.generatedContent,
           });
 
           // Find and update the message in the messages array
           setMessages((prevMessages) =>
-            prevMessages.map((m) =>
-              m.id === message.id
-                ? { ...m, attachments: generatedAttachments } as any
-                : m
-            )
+            prevMessages.map((m) => {
+              if (m.id !== message.id) return m;
+
+              // Build updated message with attachments
+              const updatedMessage: any = {
+                ...m,
+                attachments: generatedAttachments,
+              };
+
+              // If content was generated from attachments, add it to parts
+              if (persistResult?.generatedContent) {
+                const existingParts = m.parts || [];
+                const hasTextPart = existingParts.some((p: any) => p.type === 'text');
+
+                if (!hasTextPart) {
+                  updatedMessage.parts = [
+                    ...existingParts,
+                    { type: 'text', text: persistResult.generatedContent }
+                  ];
+                }
+              }
+
+              return updatedMessage;
+            })
           );
         }
       }

src/renderer/stores/chatStore.ts

@@ -41,7 +41,8 @@ interface ChatStore {
   startNewChat: () => void;
 
   // Message persistence (called by useChat onFinish callback)
-  persistMessage: (message: UIMessage) => Promise<void>;
+  // Returns generated content if attachments were converted to text markers
+  persistMessage: (message: UIMessage) => Promise<{ generatedContent?: string } | void>;
   loadHistoricalMessages: (sessionId: string) => Promise<UIMessage[]>;
 
   // Deep link actions
@@ -334,22 +335,51 @@ export const useChatStore = create<ChatStore>()(
       },
 
       // Message persistence
-      persistMessage: async (message: UIMessage) => {
+      persistMessage: async (message: UIMessage): Promise<{ generatedContent?: string } | void> => {
         const { currentSession } = get();
 
         if (!currentSession) {
           logger.database.warn('Cannot persist message: no active session');
           return;
         }
 
+        let generatedContent: string | undefined;
+
         try {
           // Extract text content from parts
           const textParts = message.parts.filter((p) => p.type === 'text');
-          const content = textParts
+          let content = textParts
             .map((p: any) => p.text)
             .join('\n')
             .trim();
 
+          // Extract attachments if present (from UIMessage extension)
+          const attachments = (message as any).attachments || undefined;
+
+          // If no text content but has attachments, generate hidden content marker for AI context
+          if (!content && attachments && attachments.length > 0) {
+            // Get base path for absolute paths
+            const basePathResult = await window.levante.attachments.getBasePath();
+            const basePath = basePathResult.success ? basePathResult.data : '';
+
+            content = attachments
+              .map((att: any) => {
+                const relativePath = att.path || att.storagePath;
+                const absolutePath = basePath ? `${basePath}/${relativePath}` : relativePath;
+                return `[attachment:${att.type}:${absolutePath}:${att.filename}]`;
+              })
+              .join('\n');
+
+            // Store generated content to return to caller
+            generatedContent = content;
+
+            logger.core.info('Generated content from attachments', {
+              messageId: message.id,
+              attachmentCount: attachments.length,
+              generatedContent: content,
+            });
+          }
+
           // Extract tool calls from parts
           const toolCallParts = message.parts.filter((p) =>
             p.type.startsWith('tool-')
@@ -366,9 +396,6 @@ export const useChatStore = create<ChatStore>()(
             }));
           }
 
-          // Extract attachments if present (from UIMessage extension)
-          const attachments = (message as any).attachments || undefined;
-
           // Debug: Log attachments being persisted
           if (attachments) {
             logger.core.info('💾 Persisting message WITH attachments', {
@@ -436,6 +463,11 @@ export const useChatStore = create<ChatStore>()(
             error: err instanceof Error ? err.message : err,
           });
         }
+
+        // Return generated content if any (for updating UI state)
+        if (generatedContent) {
+          return { generatedContent };
+        }
       },
 
       loadHistoricalMessages: async (sessionId: string): Promise<UIMessage[]> => {