jp.keijiro.ai.assistant.extensions 1.1.3 → 1.2.1

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.2.1] - 2026-06-05
+
+### Changed
+
+- Prefixed saved conversation filenames with the conversation's date and time so exported files sort chronologically.
+
+## [1.2.0] - 2026-06-05
+
+### Changed
+
+- Reworked the Conversation Extractor to read conversations through the AI Assistant in-process API instead of parsing the relay log.
+- Rebuilt the Conversation Extractor window with UI Toolkit, adding a resizable conversation list, per-conversation selection, a scrollable read-only transcript, and a toggle for including tool calls.
+- Updated project and package metadata for AI Assistant 2.11.0-pre.1.
+
 ## [1.1.3] - 2026-05-15
 
 ### Fixed

package/Editor/ConversationExtractorWindow.cs

@@ -1,227 +1,580 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Reflection;
 using System.Text;
-using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
 using UnityEditor;
+using UnityEditor.UIElements;
 using UnityEngine;
+using UnityEngine.UIElements;
 
 namespace AIAssistantExtensions {
 
+// Lists the (Unity-hosted) conversations from the AI Assistant package's in-process
+// API and extracts whichever one you pick. Everything in that API is internal and
+// our assembly is not on its InternalsVisibleTo allowlist, so we reach it through
+// reflection. The live IAssistantProvider only exists while an AI Assistant window
+// is open, so that window must be open for this to work.
 class ConversationExtractorWindow : EditorWindow
 {
-    const string RelayLogRelativePath = "Logs/relay.txt";
+    const string AssetDir = "Packages/jp.keijiro.ai.assistant.extensions/Editor/";
+    const string UxmlPath = AssetDir + "ConversationExtractorWindow.uxml";
+    const string RowUxmlPath = AssetDir + "ConversationRow.uxml";
+    const string UssPath = AssetDir + "ConversationExtractorWindow.uss";
 
-    static readonly Regex MessageRegex = new(
-      "\"\\$type\":\"(?<type>[^\"]+)\".*?\"message_id\":\"(?<messageId>[^\"]+)\".*?(?:\"last_message\":(?<lastMessage>true|false).*?)?\"markdown\":\"(?<markdown>(?:\\\\.|[^\"\\\\])*)\"",
-      RegexOptions.Compiled);
+    const string AssistantWindowTypeName = "Unity.AI.Assistant.UI.Editor.Scripts.AssistantWindow";
+    const int EventTimeoutMs = 20000;
 
-    Vector2 _scroll;
+    const BindingFlags InstanceMembers =
+      BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+
+    struct ConversationItem
+    {
+        public object IdBoxed;   // boxed AssistantConversationId, passed straight back to the API
+        public string Id;        // its string value, used to match the load callback
+        public string Title;
+        public long Timestamp;
+        public bool Favorite;
+    }
+
+    readonly List<ConversationItem> _conversations = new();
+
+    object _loadedConversation;  // last loaded conversation, for rebuilding without re-fetching
     string _markdown;
-    string _status;
-    bool _includeEmpty;
+    string _status;      // right pane: extraction lifecycle only
+    string _listStatus;  // left pane: empty-state message
+    bool _busy;
+    bool _extracting;
+    bool _includeToolCalls = true;
+
+    // UI elements (resolved in CreateGUI).
+    VisualTreeAsset _rowTemplate;
+    ToolbarButton _refreshButton;
+    Toggle _toolCallsToggle;
+    ToolbarButton _copyButton;
+    ToolbarButton _saveButton;
+    Label _listHeader;
+    Label _emptyLabel;
+    ListView _listView;
+    TextField _preview;
+
+    // Event plumbing shared with the reflection callbacks.
+    Delegate _refreshedHandler;
+    Delegate _loadedHandler;
+    TaskCompletionSource<object> _refreshTcs;
+    TaskCompletionSource<object> _loadTcs;
+    string _pendingLoadId;
 
     [MenuItem("Window/AI/Conversation Extractor")]
     static void Open()
     {
         var window = GetWindow<ConversationExtractorWindow>();
         window.titleContent = new GUIContent("Conversation Extractor");
-        window.minSize = new Vector2(480, 320);
-        window.Extract();
+        window.minSize = new Vector2(640, 360);
     }
 
-    void OnGUI()
+    // --- UI construction ----------------------------------------------------
+
+    void CreateGUI()
     {
-        using (new EditorGUILayout.HorizontalScope(EditorStyles.toolbar))
+        var tree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(UxmlPath);
+        if (tree == null)
         {
-            var includeEmpty = GUILayout.Toggle(_includeEmpty, "Include Empty", EditorStyles.toolbarButton);
-            if (includeEmpty != _includeEmpty) _includeEmpty = includeEmpty;
+            rootVisualElement.Add(new Label($"Layout asset not found: {UxmlPath}"));
+            return;
+        }
 
-            GUILayout.FlexibleSpace();
+        tree.CloneTree(rootVisualElement);
 
-            if (GUILayout.Button("Extract", EditorStyles.toolbarButton))
-                Extract();
-            if (GUILayout.Button("Copy", EditorStyles.toolbarButton))
-                CopyToClipboard();
-            if (GUILayout.Button("Save", EditorStyles.toolbarButton))
-                SaveMarkdown();
-        }
+        var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(UssPath);
+        if (styleSheet != null)
+            rootVisualElement.styleSheets.Add(styleSheet);
+
+        _rowTemplate = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(RowUxmlPath);
+
+        _refreshButton = rootVisualElement.Q<ToolbarButton>("refresh-button");
+        _toolCallsToggle = rootVisualElement.Q<Toggle>("toolcalls-toggle");
+        _copyButton = rootVisualElement.Q<ToolbarButton>("copy-button");
+        _saveButton = rootVisualElement.Q<ToolbarButton>("save-button");
+        _listHeader = rootVisualElement.Q<Label>("list-header");
+        _emptyLabel = rootVisualElement.Q<Label>("empty-label");
+        _listView = rootVisualElement.Q<ListView>("conversation-list");
+        _preview = rootVisualElement.Q<TextField>("preview");
+
+        _refreshButton.clicked += () => { if (!_busy) _ = RefreshList(); };
+        _copyButton.clicked += CopyToClipboard;
+        _saveButton.clicked += SaveMarkdown;
 
-        if (!string.IsNullOrEmpty(_status))
-            EditorGUILayout.HelpBox(_status, MessageType.Info);
+        _toolCallsToggle.SetValueWithoutNotify(_includeToolCalls);
+        _toolCallsToggle.RegisterValueChangedCallback(evt => OnToolCallsChanged(evt.newValue));
 
-        using var scroll = new EditorGUILayout.ScrollViewScope(_scroll);
-        _scroll = scroll.scrollPosition;
-        EditorGUILayout.TextArea(_markdown ?? "", GUILayout.ExpandHeight(true));
+        _listView.itemsSource = _conversations;
+        _listView.makeItem = MakeRow;
+        _listView.bindItem = BindRow;
+        _listView.selectionChanged += OnSelectionChanged;
+
+        // Show the initial hint; RefreshList drives the toolbar and list state.
+        UpdatePreview();
+        _ = RefreshList();
     }
 
-    void Extract()
+    VisualElement MakeRow()
+    {
+        if (_rowTemplate != null)
+            return _rowTemplate.Instantiate();
+
+        var container = new VisualElement();
+        container.Add(new Label { name = "row-title" });
+        container.Add(new Label { name = "row-date" });
+        return container;
+    }
+
+    void BindRow(VisualElement element, int index)
+    {
+        var item = _conversations[index];
+
+        var title = element.Q<Label>("row-title");
+        // Titles can contain embedded newlines; collapse them so the row stays
+        // single-line (white-space:nowrap doesn't strip explicit line breaks).
+        title.text = (item.Favorite ? "★ " : "") + SingleLine(DisplayTitle(item.Title));
+
+        var date = element.Q<Label>("row-date");
+        var formatted = FormatDate(item.Timestamp);
+        date.text = formatted;
+        date.style.display = string.IsNullOrEmpty(formatted) ? DisplayStyle.None : DisplayStyle.Flex;
+    }
+
+    void OnSelectionChanged(IEnumerable<object> selection)
+    {
+        if (_busy) return;
+
+        var index = _listView.selectedIndex;
+        if (index >= 0 && index < _conversations.Count)
+            _ = ExtractConversation(_conversations[index]);
+    }
+
+    void OnToolCallsChanged(bool include)
+    {
+        _includeToolCalls = include;
+
+        // Rebuild from the already-loaded conversation; no need to re-fetch.
+        if (_busy || _loadedConversation == null) return;
+        _markdown = BuildConversationMarkdown(_loadedConversation, _includeToolCalls);
+        UpdateToolbar();
+        UpdatePreview();
+    }
+
+    // --- State -> UI --------------------------------------------------------
+
+    void UpdateToolbar()
     {
-        var path = GetRelayLogPath();
-        if (!File.Exists(path))
+        _refreshButton?.SetEnabled(!_busy);
+
+        var hasMarkdown = !_busy && !string.IsNullOrEmpty(_markdown);
+        _copyButton?.SetEnabled(hasMarkdown);
+        _saveButton?.SetEnabled(hasMarkdown);
+    }
+
+    void UpdateList()
+    {
+        if (_listView == null) return;
+
+        _listHeader.text = $"Conversations ({_conversations.Count})";
+        _listView.Rebuild();
+
+        var empty = _conversations.Count == 0;
+        _listView.style.display = empty ? DisplayStyle.None : DisplayStyle.Flex;
+        _emptyLabel.style.display = empty ? DisplayStyle.Flex : DisplayStyle.None;
+        if (empty)
+            _emptyLabel.text = _busy
+              ? "Loading..."
+              : (string.IsNullOrEmpty(_listStatus) ? "No conversations." : _listStatus);
+    }
+
+    void UpdatePreview()
+    {
+        if (_preview == null) return;
+
+        // While extracting show the status text; otherwise the extracted markdown,
+        // or a hint when there is none.
+        string content;
+        if (_extracting)
+            content = _status;
+        else if (!string.IsNullOrEmpty(_markdown))
+            content = _markdown;
+        else
+            content = string.IsNullOrEmpty(_status) ? "Select a conversation to extract." : _status;
+
+        _preview.SetValueWithoutNotify(content ?? "");
+    }
+
+    // --- Operations ---------------------------------------------------------
+
+    async Task RefreshList()
+    {
+        object provider = null;
+        _busy = true;
+        _listStatus = null;
+        UpdateToolbar();
+        UpdateList();
+
+        try
         {
+            provider = GetLiveProvider(out var error);
+            if (provider == null) { _listStatus = error; return; }
+
+            Subscribe(provider);
+
+            _conversations.Clear();
+            _conversations.AddRange((await RefreshConversations(provider))
+              .OrderByDescending(c => c.Timestamp));
+            _loadedConversation = null;
             _markdown = "";
-            _status = $"Relay log not found: {path}";
-            return;
+            _status = null;
+            _listView?.SetSelectionWithoutNotify(Array.Empty<int>());
         }
+        catch (Exception e)
+        {
+            _listStatus = $"Failed to refresh: {e.Message}";
+            Debug.LogException(e);
+        }
+        finally
+        {
+            Unsubscribe(provider);
+            _busy = false;
+            UpdateToolbar();
+            UpdateList();
+            UpdatePreview();
+        }
+    }
+
+    async Task ExtractConversation(ConversationItem item)
+    {
+        object provider = null;
+        _busy = true;
+        _extracting = true;
+        _status = $"Extracting \"{DisplayTitle(item.Title)}\"...";
+        UpdateToolbar();
+        UpdatePreview();
+
+        try
+        {
+            provider = GetLiveProvider(out var error);
+            if (provider == null) { _markdown = ""; _status = error; return; }
 
-        var pairs = ExtractPairs(path);
-        _markdown = BuildMarkdown(pairs, _includeEmpty);
-        _status = $"Extracted {pairs.Count} conversation pair(s) from {RelayLogRelativePath}.";
+            Subscribe(provider);
+
+            var conversation = await LoadConversation(provider, item);
+            _loadedConversation = conversation;
+            _markdown = BuildConversationMarkdown(conversation, _includeToolCalls);
+            _status = null;
+        }
+        catch (Exception e)
+        {
+            _loadedConversation = null;
+            _markdown = "";
+            _status = $"Extraction failed: {e.Message}";
+            Debug.LogException(e);
+        }
+        finally
+        {
+            Unsubscribe(provider);
+            _busy = false;
+            _extracting = false;
+            UpdateToolbar();
+            UpdatePreview();
+        }
     }
 
     void CopyToClipboard()
     {
         EditorGUIUtility.systemCopyBuffer = _markdown ?? "";
-        _status = "Copied extracted markdown to the clipboard.";
+        ShowNotification(new GUIContent("Copied to clipboard"));
     }
 
     void SaveMarkdown()
     {
-        var projectRoot = GetProjectRootPath();
-        var defaultPath = Path.Combine(projectRoot, "Logs", "conversations.md");
-        var path = EditorUtility.SaveFilePanel("Save extracted conversations", Path.GetDirectoryName(defaultPath), Path.GetFileName(defaultPath), "md");
+        var projectRoot = Directory.GetParent(Application.dataPath)?.FullName ?? Directory.GetCurrentDirectory();
+        var index = _listView?.selectedIndex ?? -1;
+        var hasSelection = index >= 0 && index < _conversations.Count;
+        var name = hasSelection ? SanitizeFileName(_conversations[index].Title) : "conversation";
+        var stamp = hasSelection ? FormatFileTimestamp(_conversations[index].Timestamp) : "";
+        var fileName = string.IsNullOrEmpty(stamp) ? name : $"{stamp} {name}";
+        var defaultPath = Path.Combine(projectRoot, "Logs", $"{fileName}.md");
+        var path = EditorUtility.SaveFilePanel("Save extracted conversation", Path.GetDirectoryName(defaultPath), Path.GetFileName(defaultPath), "md");
         if (string.IsNullOrEmpty(path)) return;
 
         File.WriteAllText(path, _markdown ?? "", Encoding.UTF8);
-        _status = $"Saved extracted markdown to {path}";
+        ShowNotification(new GUIContent($"Saved to {Path.GetFileName(path)}"));
     }
 
-    static List<ConversationPair> ExtractPairs(string path)
+    // --- Live provider acquisition -----------------------------------------
+
+    static object GetLiveProvider(out string error)
     {
-        var pairs = new List<ConversationPair>();
-        ConversationPair currentPair = null;
-        string activeResponseId = null;
+        error = null;
 
-        var lines = File.ReadAllLines(path, Encoding.UTF8);
-        for (var i = 0; i < lines.Length; i++)
+        var windowType = FindType(AssistantWindowTypeName);
+        if (windowType == null)
         {
-            var parsed = ParseLine(lines[i]);
-            if (parsed == null) continue;
+            error = "AI Assistant package not found. Is it installed?";
+            return null;
+        }
 
-            if (parsed.Type == "CHAT_ACKNOWLEDGMENT_V1" && !string.IsNullOrWhiteSpace(parsed.Markdown))
-            {
-                if (currentPair != null && currentPair.ResponseParts.Count > 0)
-                    pairs.Add(currentPair);
+        var window = windowType
+          .GetMethod("FindExistingWindow", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+          ?.Invoke(null, null);
+        if (window == null)
+        {
+            error = "Open the AI Assistant window first (Window > AI > Assistant), then retry.";
+            return null;
+        }
 
-                currentPair = new ConversationPair(parsed.Markdown.Trim(), i + 1, parsed.MessageId);
-                activeResponseId = null;
-                continue;
-            }
+        var provider = windowType.GetProperty("AssistantInstance", InstanceMembers)?.GetValue(window);
+        if (provider == null)
+            error = "AI Assistant instance is not ready yet. Interact with the Assistant window, then retry.";
 
-            if (parsed.Type != "CHAT_RESPONSE_V1" || currentPair == null) continue;
-            if (string.IsNullOrEmpty(parsed.Markdown) || parsed.Markdown.StartsWith("<")) continue;
+        return provider;
+    }
 
-            if (activeResponseId == null)
-            {
-                activeResponseId = parsed.MessageId;
-                currentPair.ResponseMessageId = activeResponseId;
-            }
+    // --- Event-driven calls -------------------------------------------------
 
-            if (parsed.MessageId == activeResponseId)
-            {
-                currentPair.ResponseParts.Add(parsed.Markdown);
-                currentPair.ResponseLines.Add(i + 1);
-            }
+    async Task<List<ConversationItem>> RefreshConversations(object provider)
+    {
+        _refreshTcs = new TaskCompletionSource<object>();
 
-            if (parsed.LastMessage && parsed.MessageId == activeResponseId)
+        var method = provider.GetType().GetMethod(
+          "RefreshConversationsAsync", InstanceMembers,
+          null, new[] { typeof(CancellationToken), typeof(bool) }, null);
+        if (method == null)
+            throw new MissingMethodException("IAssistantProvider.RefreshConversationsAsync not found.");
+
+        await (Task)method.Invoke(provider, new object[] { CancellationToken.None, false });
+        var infos = await WithTimeout(_refreshTcs.Task);
+
+        // The event delivers IEnumerable<AssistantConversationInfo> (a boxed struct per item).
+        var result = new List<ConversationItem>();
+        foreach (var info in (IEnumerable)infos)
+        {
+            var idBoxed = GetMember(info, "Id");
+            result.Add(new ConversationItem
             {
-                pairs.Add(currentPair);
-                currentPair = null;
-                activeResponseId = null;
-            }
+                IdBoxed = idBoxed,
+                Id = GetMember(idBoxed, "Value") as string,
+                Title = GetMember(info, "Title") as string,
+                Timestamp = Convert.ToInt64(GetMember(info, "LastMessageTimestamp") ?? 0L),
+                Favorite = GetMember(info, "IsFavorite") is true
+            });
         }
+        return result;
+    }
+
+    async Task<object> LoadConversation(object provider, ConversationItem item)
+    {
+        _pendingLoadId = item.Id;
+        _loadTcs = new TaskCompletionSource<object>();
 
-        if (currentPair != null)
-            pairs.Add(currentPair);
+        var method = provider.GetType().GetMethod("ConversationLoad", InstanceMembers);
+        if (method == null)
+            throw new MissingMethodException("IAssistantProvider.ConversationLoad not found.");
 
-        return pairs;
+        await (Task)method.Invoke(provider, new[] { item.IdBoxed, CancellationToken.None });
+        return await WithTimeout(_loadTcs.Task);
     }
 
-    static ParsedLine ParseLine(string line)
+    static async Task<object> WithTimeout(Task<object> task)
     {
-        var match = MessageRegex.Match(line);
-        if (!match.Success) return null;
+        if (await Task.WhenAny(task, Task.Delay(EventTimeoutMs)) != task)
+            throw new TimeoutException("Timed out waiting for the AI Assistant API to respond.");
+        return await task;
+    }
+
+    void Subscribe(object provider)
+    {
+        var type = provider.GetType();
+
+        // Bind handlers taking `object` to Action<T> events via delegate contravariance.
+        var refreshedEvent = type.GetEvent("ConversationsRefreshed", InstanceMembers);
+        _refreshedHandler = Delegate.CreateDelegate(
+          refreshedEvent.EventHandlerType, this,
+          GetType().GetMethod(nameof(OnConversationsRefreshed), InstanceMembers));
+        refreshedEvent.AddEventHandler(provider, _refreshedHandler);
+
+        var loadedEvent = type.GetEvent("ConversationLoaded", InstanceMembers);
+        _loadedHandler = Delegate.CreateDelegate(
+          loadedEvent.EventHandlerType, this,
+          GetType().GetMethod(nameof(OnConversationLoaded), InstanceMembers));
+        loadedEvent.AddEventHandler(provider, _loadedHandler);
+    }
 
-        return new ParsedLine
-        (
-            match.Groups["type"].Value,
-            match.Groups["messageId"].Value,
-            match.Groups["lastMessage"].Value == "true",
-            DecodeMarkdown(match.Groups["markdown"].Value)
-        );
+    void Unsubscribe(object provider)
+    {
+        if (provider == null) return;
+
+        var type = provider.GetType();
+        if (_refreshedHandler != null)
+            type.GetEvent("ConversationsRefreshed", InstanceMembers)?.RemoveEventHandler(provider, _refreshedHandler);
+        if (_loadedHandler != null)
+            type.GetEvent("ConversationLoaded", InstanceMembers)?.RemoveEventHandler(provider, _loadedHandler);
+
+        _refreshedHandler = _loadedHandler = null;
+    }
+
+    // Reflection callbacks. May arrive on a background thread; TaskCompletionSource
+    // marshals the awaiting continuation back to the captured (main) context.
+    void OnConversationsRefreshed(object infos) => _refreshTcs?.TrySetResult(infos);
+
+    void OnConversationLoaded(object conversation)
+    {
+        var id = GetMember(GetMember(conversation, "Id"), "Value") as string;
+        if (_loadTcs != null && id == _pendingLoadId)
+            _loadTcs.TrySetResult(conversation);
     }
 
-    static string DecodeMarkdown(string value)
-      => JsonUtility.FromJson<JsonStringWrapper>("{\"value\":\"" + value + "\"}")?.value ?? "";
+    // --- Markdown building --------------------------------------------------
 
-    static string BuildMarkdown(List<ConversationPair> pairs, bool includeEmpty)
+    static string BuildConversationMarkdown(object conversation, bool includeToolCalls)
     {
+        if (conversation == null) return "";
+
         var builder = new StringBuilder();
+        var title = GetMember(conversation, "Title") as string;
+        builder.Append("# ").Append(DisplayTitle(title));
 
-        foreach (var pair in pairs)
+        if (GetMember(conversation, "Messages") is IEnumerable messages)
         {
-            var response = pair.Response.Trim();
-            if (!includeEmpty && string.IsNullOrEmpty(response)) continue;
-
-            if (builder.Length > 0)
-                builder.Append("\n\n");
+            foreach (var message in messages)
+            {
+                var text = ExtractMessageText(message, includeToolCalls);
+                if (string.IsNullOrWhiteSpace(text)) continue;
 
-            builder.Append("## User\n\n");
-            builder.Append(pair.Prompt);
-            builder.Append("\n\n## Assistant\n\n");
-            builder.Append(string.IsNullOrEmpty(response) ? "(No extracted response)" : response);
+                var role = GetMember(message, "Role") as string;
+                builder.Append("\n\n## ").Append(FormatRole(role)).Append("\n\n");
+                builder.Append(text.Trim());
+            }
         }
 
         return builder.ToString();
     }
 
-    static string GetProjectRootPath()
-      => Directory.GetParent(Application.dataPath)?.FullName ?? Directory.GetCurrentDirectory();
+    static string ExtractMessageText(object message, bool includeToolCalls)
+    {
+        if (GetMember(message, "Blocks") is not IEnumerable blocks) return "";
 
-    static string GetRelayLogPath()
-      => Path.Combine(GetProjectRootPath(), RelayLogRelativePath);
+        var parts = new List<string>();
+        foreach (var block in blocks)
+        {
+            var text = BlockText(block, includeToolCalls);
+            if (!string.IsNullOrWhiteSpace(text)) parts.Add(text.Trim());
+        }
+        return string.Join("\n\n", parts);
+    }
 
-    [Serializable]
-    class JsonStringWrapper
+    // Pulls text out of each block. Text-bearing blocks return their content;
+    // FunctionCallBlock is rendered as the tool name plus its parameters (only when
+    // tool calls are included). The ACP tool-call / plan blocks carry structured
+    // data and are skipped.
+    static string BlockText(object block, bool includeToolCalls)
     {
-        public string value = "";
+        if (block == null) return null;
+        return block.GetType().Name switch
+        {
+            "PromptBlock" => GetMember(block, "Content") as string,
+            "AnswerBlock" => GetMember(block, "Content") as string,
+            "ThoughtBlock" => GetMember(block, "Content") as string,
+            "ErrorBlock" => GetMember(block, "Error") as string,
+            "InfoBlock" => GetMember(block, "Message") as string,
+            "FunctionCallBlock" => includeToolCalls ? FormatFunctionCall(GetMember(block, "Call")) : null,
+            _ => null
+        };
     }
 
-    class ConversationPair
+    // Renders an AssistantFunctionCall (e.g. CodeEdit) as a tool name plus its
+    // parameters. Parameters is a Newtonsoft JObject, whose ToString() yields
+    // indented JSON, so no compile-time dependency on Newtonsoft is needed.
+    static string FormatFunctionCall(object call)
     {
-        public readonly string Prompt;
-        public readonly int PromptLine;
-        public readonly string PromptMessageId;
-        public readonly List<string> ResponseParts = new();
-        public readonly List<int> ResponseLines = new();
-        public string ResponseMessageId;
+        if (call == null) return null;
 
-        public string Response => string.Concat(ResponseParts);
+        var name = GetMember(call, "FunctionId") as string;
+        var builder = new StringBuilder();
+        builder.Append("**Tool call: ").Append(string.IsNullOrEmpty(name) ? "(unknown)" : name).Append("**");
 
-        public ConversationPair(string prompt, int promptLine, string promptMessageId)
-        {
-            Prompt = prompt;
-            PromptLine = promptLine;
-            PromptMessageId = promptMessageId;
-        }
+        var parameters = GetMember(call, "Parameters")?.ToString();
+        if (!string.IsNullOrWhiteSpace(parameters))
+            builder.Append("\n\n```json\n").Append(parameters).Append("\n```");
+
+        return builder.ToString();
     }
 
-    class ParsedLine
+    // --- Misc helpers -------------------------------------------------------
+
+    static string DisplayTitle(string title)
+      => string.IsNullOrEmpty(title) ? "(Untitled)" : title;
+
+    // Collapses CR/LF runs to single spaces so a value renders on one line.
+    static string SingleLine(string text)
+      => string.IsNullOrEmpty(text)
+         ? text
+         : System.Text.RegularExpressions.Regex.Replace(text, @"\s+", " ").Trim();
+
+    static string FormatRole(string role)
     {
-        public readonly string Type;
-        public readonly string MessageId;
-        public readonly bool LastMessage;
-        public readonly string Markdown;
+        if (string.IsNullOrEmpty(role)) return "Message";
+        return char.ToUpperInvariant(role[0]) + role.Substring(1);
+    }
+
+    static string FormatDate(long timestamp)
+      => TryGetLocalTime(timestamp, out var time) ? time.ToString("yyyy-MM-dd HH:mm") : "";
 
-        public ParsedLine(string type, string messageId, bool lastMessage, string markdown)
+    // Date and time for filenames; colon-free so it is filesystem-safe and sortable.
+    static string FormatFileTimestamp(long timestamp)
+      => TryGetLocalTime(timestamp, out var time) ? time.ToString("yyyy-MM-dd HH-mm") : "";
+
+    static bool TryGetLocalTime(long timestamp, out DateTimeOffset time)
+    {
+        time = default;
+        if (timestamp <= 0) return false;
+        try
+        {
+            time = (timestamp > 1_000_000_000_000L
+              ? DateTimeOffset.FromUnixTimeMilliseconds(timestamp)
+              : DateTimeOffset.FromUnixTimeSeconds(timestamp)).ToLocalTime();
+            return true;
+        }
+        catch
         {
-            Type = type;
-            MessageId = messageId;
-            LastMessage = lastMessage;
-            Markdown = markdown;
+            return false;
         }
     }
+
+    static string SanitizeFileName(string name)
+    {
+        if (string.IsNullOrEmpty(name)) return "conversation";
+        var invalid = Path.GetInvalidFileNameChars();
+        var sanitized = new string(name.Select(c => invalid.Contains(c) ? '_' : c).ToArray()).Trim();
+        return string.IsNullOrEmpty(sanitized) ? "conversation" : sanitized;
+    }
+
+    static Type FindType(string fullName)
+      => AppDomain.CurrentDomain.GetAssemblies()
+          .Select(a => a.GetType(fullName, false))
+          .FirstOrDefault(t => t != null);
+
+    // Reads a public/internal field or property by name from a live object
+    // (works on boxed structs too).
+    static object GetMember(object obj, string name)
+    {
+        if (obj == null) return null;
+        var type = obj.GetType();
+        var field = type.GetField(name, InstanceMembers);
+        if (field != null) return field.GetValue(obj);
+        return type.GetProperty(name, InstanceMembers)?.GetValue(obj);
+    }
 }
 
 } // namespace AIAssistantExtensions

package/Editor/ConversationExtractorWindow.uss

@@ -0,0 +1,80 @@
+.unity-text-element {
+    -unity-font-definition: url("project://database/Packages/jp.keijiro.ai.assistant.extensions/Editor/NotoSansJP-Regular.ttf?fileID=12800000&guid=f7d2dd1a328194df9b71491ff2d07e2b&type=3#NotoSansJP-Regular");
+}
+
+.spacer {
+    flex-grow: 1;
+}
+
+.split {
+    flex-grow: 1;
+}
+
+#left-pane {
+    min-width: 150px;
+}
+
+#right-pane {
+    min-width: 200px;
+}
+
+.pane {
+    flex-grow: 1;
+    min-height: 0;
+    padding: 4px;
+}
+
+.header {
+    -unity-font-style: bold;
+    margin-top: 2px;
+    margin-bottom: 2px;
+}
+
+.preview-header {
+    flex-direction: row;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.toolcalls {
+    margin-bottom: 2px;
+}
+
+.empty {
+    white-space: normal;
+    opacity: 0.6;
+    margin: 4px;
+}
+
+.list {
+    flex-grow: 1;
+}
+
+.preview {
+    flex-grow: 1;
+    flex-shrink: 1;
+    min-height: 0;
+}
+
+.preview .unity-base-text-field__input {
+    white-space: normal;
+    -unity-text-align: upper-left;
+}
+
+.row {
+    justify-content: center;
+    padding-left: 6px;
+    padding-right: 6px;
+}
+
+.row-title {
+    -unity-font-style: bold;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    white-space: nowrap;
+}
+
+.row-date {
+    font-size: 10px;
+    opacity: 0.65;
+}

package/Editor/ConversationExtractorWindow.uss.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f6331e5dc7a84404baedc43bf6c5b522
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+  unsupportedSelectorAction: 0

package/Editor/ConversationExtractorWindow.uxml

@@ -0,0 +1,23 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="True">
+    <Style src="project://database/Packages/jp.keijiro.ai.assistant.extensions/Editor/ConversationExtractorWindow.uss?fileID=7433441132597879392&amp;guid=f6331e5dc7a84404baedc43bf6c5b522&amp;type=3#ConversationExtractorWindow"/>
+    <uie:Toolbar>
+        <uie:ToolbarButton name="refresh-button" text="Refresh"/>
+        <ui:VisualElement class="spacer"/>
+        <uie:ToolbarButton name="copy-button" text="Copy"/>
+        <uie:ToolbarButton name="save-button" text="Save"/>
+    </uie:Toolbar>
+    <ui:TwoPaneSplitView name="split" orientation="Horizontal" fixed-pane-index="0" fixed-pane-initial-dimension="240" view-data-key="split" class="split">
+        <ui:VisualElement name="left-pane" class="pane">
+            <ui:Label name="list-header" class="header"/>
+            <ui:ListView name="conversation-list" view-data-key="list" fixed-item-height="38" selection-type="Single" class="list"/>
+            <ui:Label name="empty-label" class="empty"/>
+        </ui:VisualElement>
+        <ui:VisualElement name="right-pane" class="pane">
+            <ui:VisualElement name="preview-header" class="preview-header">
+                <ui:Label text="Extracted Markdown" class="header"/>
+                <ui:Toggle name="toolcalls-toggle" text="Tool Calls" class="toolcalls"/>
+            </ui:VisualElement>
+            <ui:TextField name="preview" multiline="true" readonly="true" vertical-scroller-visibility="Auto" focusable="false" class="preview"/>
+        </ui:VisualElement>
+    </ui:TwoPaneSplitView>
+</ui:UXML>

package/Editor/ConversationExtractorWindow.uxml.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7a48f083d5c894030ae036790fba1881
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}

package/Editor/ConversationRow.uxml

@@ -0,0 +1,6 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements">
+    <ui:VisualElement class="row">
+        <ui:Label name="row-title" class="row-title"/>
+        <ui:Label name="row-date" class="row-date"/>
+    </ui:VisualElement>
+</ui:UXML>

package/Editor/ConversationRow.uxml.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: d67de4ce2aaaa4897b5c8a3355889f53
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "jp.keijiro.ai.assistant.extensions",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "displayName": "AI Assistant Extensions",
   "description": "Custom Unity package that provides extensions for Unity AI Assistant.",
   "unity": "6000.0",
   "author": "Keijiro Takahashi",
   "dependencies": {
-    "com.unity.ai.assistant": "2.8.0-pre.1"
+    "com.unity.ai.assistant": "2.11.0-pre.1"
   },
   "changelogUrl": "https://github.com/keijiro/AIA-Extensions/blob/master/CHANGELOG.md",
   "documentationUrl": "https://github.com/keijiro/AIA-Extensions",
   "licensesUrl": "https://github.com/keijiro/AIA-Extensions/blob/master/LICENSE",
   "license": "Unlicense",
   "_upm": {
-    "changelog": "<b>Fixed</b><br>- Fixed package skill registration for AI Assistant 2.8.0-pre.1 by using the built-in package skill discovery path.<br><br><b>Changed</b><br>- Updated project and package metadata for AI Assistant 2.8.0-pre.1."
+    "changelog": "<b>Changed</b><br>- Prefixed saved conversation filenames with the conversation's date and time so exported files sort chronologically."
   },
   "repository": {
     "url": "git@github.com:keijiro/AIA-Extensions.git",
     "type": "git",
-    "revision": "9ad87b2c94f8c38a28b03572585ea6de1c438e2b"
+    "revision": "6c89672e11d612d4416afa8f114af153fae8ec6a"
   }
 }