Extending Chip Kinds in In-Unity Chat¶

{
  "name": "MyPlugin.Chat",
  "references": ["UnityMCP.Editor.Chat.CLI"],
  "autoReferenced": false
}

using UnityEditor;
using UnityEngine;
using UnityEngine.UIElements;
using UnityMCP.Editor.Chat;

namespace MyPlugin.Chat
{
    [InitializeOnLoad]
    internal sealed class CustomAssetChipProvider : IChipKindProvider
    {
        // Static ctor runs on domain-load
        static CustomAssetChipProvider() => ChipKindRegistry.Register(new CustomAssetChipProvider());

        // Unique identifier for this kind
        public string Key => "custom_asset";

        // Lower numbers = checked first during detection
        // Built-ins use 40–700 (Asset fallback = int.MaxValue); plugin overrides use <40, extensions use >700
        public int Priority => 900;

        // Return true if this provider handles the object
        public bool CanHandle(Object obj, string assetPath)
        {
            // Example: detect custom asset type by extension
            return !string.IsNullOrEmpty(assetPath) && assetPath.EndsWith(".myasset");
        }

        // Create a chip for the object (called once per drag-drop)
        public ChipData Create(Object obj, string assetPath)
        {
            return new ChipData(
                kindKey: Key,
                path: assetPath,
                displayName: obj.name,
                instanceID: 0  // Assets don't have instance IDs
            );
        }

        // Icon displayed in the chip pill
        // Use EditorGUIUtility.IconContent(name).image names
        public string IconName => "d_Prefab Icon";  // Any Unity icon name works

        // Hex color for the pill background and response tag
        public string HexColor => "#ff9500";

        // Default depth when user hasn't configured one in settings
        // Options: "none", "path", "summary", "full"
        // "none" = omit from AI context entirely
        // "path" = just the file path (token-efficient)
        // "summary" = path + 3 top-level properties (common)
        // "full" = path + all serialized state (expensive)
        public string DefaultDepth => "path";

        // File extensions that should be recognized as bare-path references of this kind
        // in assistant responses (e.g., "img.png" -> [image:img/png]).
        // Return System.Array.Empty<string>() if this kind has no bare-path form.
        public string[] BarePathExtensions => new[] { ".myasset" };

        // Format the AI-facing payload
        // Called with resolved summary (if depth includes it)
        // Return empty string to omit from context entirely
        public string FormatPayload(ChipData chip, ChipPayloadContext ctx)
        {
            // ctx.Depth tells us what the user configured (or DefaultDepth if unconfigured)
            // ctx.ResolvedSummary (if depth="summary"|"full") has pre-resolved component list

            if (ctx.Depth == "none")
                return "";  // Omit entirely

            if (ctx.Depth == "path")
                return $"[{Key}:{chip.Path}]";

            if (ctx.Depth == "summary" || ctx.Depth == "full")
            {
                // Include summary if available
                var summary = !string.IsNullOrEmpty(ctx.ResolvedSummary)
                    ? "\n" + ctx.ResolvedSummary
                    : "";
                return $"[{Key}:{chip.Path}]{summary}";
            }

            return "";
        }

        // Handle a click on a chip link in the transcript
        // reference = the path from the chip linkId (e.g., "Assets/MyAsset.myasset")
        public void Navigate(string reference)
        {
            var asset = AssetDatabase.LoadAssetAtPath<Object>(reference);
            if (asset == null)
            {
                Debug.LogWarning($"[Chat] Asset not found: {reference}");
                return;
            }
            AssetDatabase.OpenAsset(asset);
        }

        // Highlight/ping the referenced object when an inline preview is first shown.
        // Usually the same as Navigate, but without opening a dedicated editor window.
        public void Ping(string reference)
        {
            var asset = AssetDatabase.LoadAssetAtPath<Object>(reference);
            if (asset == null) return;
            EditorGUIUtility.PingObject(asset);
            Selection.activeObject = asset;
        }

        // Append custom menu items to the chip's context menu (right-click on transcript chip).
        // This allows plugins to add actions beyond the default Navigate/Ping/Copy options.
        public void AppendContextMenuItems(DropdownMenu menu, string reference)
        {
            menu.AppendAction("Custom Action", action =>
            {
                var asset = AssetDatabase.LoadAssetAtPath<Object>(reference);
                if (asset != null)
                {
                    Debug.Log($"Custom action invoked on {asset.name}");
                }
            });
        }
    }
}

public static class ChipKindRegistry
{
    // Register a provider (from [InitializeOnLoad])
    public static bool Register(IChipKindProvider p);

    // Unregister by key (rarely used; mainly for testing)
    public static bool Unregister(string key);

    // Find first provider that CanHandle(obj, assetPath) — used in drag-drop detection
    public static IChipKindProvider Resolve(Object obj, string assetPath);

    // Look up by exact key (used for reload-recovery)
    public static IChipKindProvider ForKey(string key);

    // Current version counter (increments on register/unregister)
    public static int Version { get; }

    // All registered keys in priority order
    public static IReadOnlyList<string> AllKeys { get; }
}

public readonly struct ChipData
{
    public readonly string KindKey;          // e.g., "custom_asset"
    public readonly string Path;             // File path or object reference
    public readonly string DisplayName;      // Shown in the pill UI
    public readonly int    InstanceID;       // 0 for assets, >0 for scene objects
    public readonly GlobalObjectId GlobalObjectId; // Stable cross-session identity (scene objects)
}

public readonly struct ChipPayloadContext
{
    public readonly string Depth;              // "none" | "path" | "summary" | "full"
    public readonly string ResolvedSummary;    // Pre-resolved component list (if depth includes it)
}

public void Navigate(string reference)
{
    var snippet = CodeSnippetDatabase.Get(reference);
    if (snippet != null)
        CodeEditor.Open(snippet.FilePath, snippet.LineNumber);
}

[Test]
public void CustomProvider_CanHandle_CustomAsset()
{
    ChipKindRegistry.ResetToBuiltIns();
    var provider = new CustomAssetChipProvider();
    ChipKindRegistry.Register(provider);

    Assert.IsTrue(provider.CanHandle(null, "Assets/MyAsset.myasset"));
    Assert.IsFalse(provider.CanHandle(null, "Assets/Texture.png"));
}