@atelierai/uco 1.0.0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/ToolGroups.cs

@@ -0,0 +1,149 @@
+/*
+ * Design inspired by MCP for Unity (CoplayDev/unity-mcp), Copyright (c) Coplay Inc., MIT License.
+ */
+
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System.ComponentModel;
+using com.AtelierAI.Uco.Framework;
+
+namespace AIGD
+{
+    /// <summary>
+    /// One row in the <c>tools-list-groups</c> response and the
+    /// <c>editor://tool-groups</c> resource payload.
+    /// </summary>
+    [Description("A logical tool group declared via [ToolGroupAttribute].")]
+    public class ToolGroupSnapshot
+    {
+        [Description("Group name (lower-case identifier, e.g. 'core', 'physics', 'vfx').")]
+        public string Name { get; set; } = string.Empty;
+
+        [Description("True when the group is currently enabled. Note: enforcement is " +
+            "currently a soft hint — disabled tools remain callable through the upstream " +
+            "request pipeline. Use 'tools-set-group-enabled' to flip state and persist it.")]
+        public bool Enabled { get; set; }
+
+        [Description("Requested group state persisted by the user. Same value as Enabled for compatibility.")]
+        public bool RequestedEnabled { get; set; }
+
+        [Description("Actual callability at the current tool boundary. This remains true for populated groups while enforcement is soft.")]
+        public bool EffectiveEnabled { get; set; }
+
+        [Description("Accepted aliases that resolve to this canonical group name.")]
+        public string[] Aliases { get; set; } = System.Array.Empty<string>();
+
+        [Description("Default-enabled flag declared by the attribute. EditorPrefs may " +
+            "override this; the diff between Enabled and DefaultEnabled tells you whether " +
+            "the user has customised the group.")]
+        public bool DefaultEnabled { get; set; }
+
+        [Description("Optional human-readable description from the attribute. May be null.")]
+        public string? Description { get; set; }
+
+        [Description("Tool ids that belong to this group (the values exposed as uco tool names).")]
+        public string[] Tools { get; set; } = System.Array.Empty<string>();
+
+        [Description("Number of tools in this group. Equal to Tools.Length; provided for " +
+            "quick LLM-side filtering without iterating the array.")]
+        public int ToolCount { get; set; }
+    }
+
+    /// <summary>
+    /// Compact result returned by <c>tools-set-group-enabled</c>.
+    /// </summary>
+    [Description("Result of a 'tools-set-group-enabled' call.")]
+    public class ToolGroupResult
+    {
+        [Description("The group name as resolved by the registry.")]
+        public string Group { get; set; } = string.Empty;
+
+        [Description("Group enabled state after the call.")]
+        public bool Enabled { get; set; }
+
+        [Description("Requested state after the call.")]
+        public bool RequestedEnabled { get; set; }
+
+        [Description("Actual callability after the call.")]
+        public bool EffectiveEnabled { get; set; }
+
+        [Description("Accepted aliases for the canonical group.")]
+        public string[] Aliases { get; set; } = System.Array.Empty<string>();
+
+        [Description("Group enabled state before the call. When equal to Enabled the call " +
+            "was a no-op and no EditorPrefs write happened.")]
+        public bool PreviousEnabled { get; set; }
+
+        [Description("True when the call changed the state (and therefore touched EditorPrefs).")]
+        public bool Changed { get; set; }
+
+        [Description("Number of tool ids that belong to the affected group.")]
+        public int ToolCount { get; set; }
+
+        [Description("Informational note. Currently always carries the soft-hint disclaimer " +
+            "explaining that enforcement is not wired into the request pipeline yet.")]
+        public string Note { get; set; } = string.Empty;
+    }
+}
+
+namespace com.AtelierAI.Unity.Copilot.Editor.API
+{
+    /// <summary>
+    /// Domain root for the <c>tools-*</c> group-management tools and the
+    /// <c>editor://tool-groups</c> resource.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class is intentionally a thin façade over
+    /// <see cref="com.AtelierAI.Unity.Copilot.Editor.Utils.ToolGroupRegistry"/>.
+    /// All scanning, enabled-state tracking, and EditorPrefs persistence
+    /// happens inside the registry; the tools below only project that state
+    /// for the LLM.
+    /// </para>
+    /// <para>
+    /// <b>Opting tools into a group.</b> Add
+    /// <c>[ToolGroup("vfx")]</c> (or any other group name) to the
+    /// partial-class root of a <c>Tool_*</c> type — the same file that carries
+    /// <c>[UcoToolType]</c>. The registry will pick it up on the next
+    /// domain reload. No existing tool files are touched in this implementation;
+    /// callers are expected to add the marker themselves on the tools they
+    /// want to gate.
+    /// </para>
+    /// <para>
+    /// <b>Soft hint, not hard enforcement.</b> Toggling a group via
+    /// <c>tools-set-group-enabled</c> updates the registry + EditorPrefs but
+    /// does <i>not</i> cause the upstream <c>IRunTool.RunCallTool</c> to reject
+    /// calls into disabled tools. That would require modifying the external
+    /// NuGet package, which is out of scope for this change. Downstream
+    /// consumers (e.g. a future <c>batch-execute</c> filter or a request
+    /// interceptor) can read <c>ToolGroupRegistry.IsToolEnabled</c> to honour
+    /// the user's choice.
+    /// </para>
+    /// </remarks>
+    [UcoToolType]
+    public partial class Tool_ToolGroups
+    {
+        public static class Error
+        {
+            public static string GroupNameIsEmpty()
+                => "Group name is null or empty. Call 'tools-list-groups' to discover valid group names.";
+
+            public static string UnknownGroup(string group)
+                => $"Unknown group '{group}'. Call 'tools-list-groups' to discover valid group names.";
+        }
+
+        internal const string SoftHintNote =
+            "Soft hint only: state is persisted via EditorPrefs, but disabled tools remain " +
+            "callable through the upstream IRunTool.RunCallTool pipeline. Enforcement would " +
+            "require hooking the request pipeline — not in scope for this change.";
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/ToolGroups.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bd32672300c008244a77a5ef2fe59373
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/Type.GetJsonSchema.cs

@@ -0,0 +1,160 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System;
+using System.ComponentModel;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization.Metadata;
+using com.AtelierAI.Uco.Framework;
+using com.IvanMurzak.ReflectorNet.Utils;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.API
+{
+    public partial class Tool_Type
+    {
+        public const string TypeGetJsonSchemaToolId = "type-get-json-schema";
+        [UcoTool
+        (
+            TypeGetJsonSchemaToolId,
+            Title = "Type / Get Json Schema",
+            ReadOnlyHint = true,
+            DestructiveHint = false,
+            IdempotentHint = true,
+            Enabled = true
+        )]
+        [UcoSkillDescription("Generate a JSON Schema for a C# type name via reflection. " +
+            "Supports primitives, enums, arrays, generic collections, dictionaries, and complex objects. " +
+            "Knobs control inclusion of nested `$defs` and whether type-level / property-level descriptions are emitted.")]
+        [UcoSkillBody("Generates a JSON Schema for a given C# type name using reflection. " +
+            "Supports primitives, enums, arrays, generic collections, dictionaries, and complex objects. " +
+            "The type must be present in any loaded assembly. " +
+            "Use the full type name (e.g. 'UnityEngine.Vector3') for best results.\n\n" +
+            "## Inputs\n\n" +
+            "- `typeName` — full type name preferred (e.g. `UnityEngine.Vector3`, `System.Collections.Generic.List<System.Int32>`). " +
+            "Simple names work when unambiguous.\n" +
+            "- `descriptionMode` (default `Ignore`) — controls type-level `description`: `Include` keeps it on the target only, " +
+            "`IncludeRecursively` also keeps it inside `$defs`, `Ignore` strips all.\n" +
+            "- `propertyDescriptionMode` (default `Ignore`) — controls property/field/item `description`: `Include` keeps " +
+            "on the target's own properties/items only, `IncludeRecursively` also keeps inside `$defs`, `Ignore` strips all.\n" +
+            "- `includeNestedTypes` (default `false`) — when true, complex nested types are extracted into `$defs` and " +
+            "referenced via `$ref`. Useful for recursive or large types.\n" +
+            "- `writeIndented` (default `false`) — pretty-print the output JSON.")]
+        [Description("Generates a JSON Schema for a given C# type name using reflection. " +
+            "Supports primitives, enums, arrays, generic collections, dictionaries, and complex objects. " +
+            "The type must be present in any loaded assembly. " +
+            "Use the full type name (e.g. 'UnityEngine.Vector3') for best results.")]
+        public string GetJsonSchema
+        (
+            [Description("Full C# type name to generate the schema for. " +
+                "Examples: 'System.String', 'UnityEngine.Vector3', 'System.Collections.Generic.List<System.Int32>'. " +
+                "Simple names like 'Vector3' are also accepted when unambiguous.")]
+            string typeName,
+
+            [Description("Controls the type-level 'description' field. " +
+                "Include: keep on the target type only. " +
+                "IncludeRecursively: keep on the target type and inside $defs entries. " +
+                "Ignore: strip all type-level descriptions. Default: Ignore.")]
+            DescriptionMode descriptionMode = DescriptionMode.Ignore,
+
+            [Description("Controls 'description' fields on properties, fields, and array items. " +
+                "Include: keep on the target type's own properties/items only. " +
+                "IncludeRecursively: keep on all properties/items including those inside $defs entries. " +
+                "Ignore: strip all property/item descriptions. Default: Ignore.")]
+            DescriptionMode propertyDescriptionMode = DescriptionMode.Ignore,
+
+            [Description("When true, complex nested types are extracted into '$defs' and referenced via '$ref' " +
+                "instead of being inlined. Useful for large or recursive types. Default: false.")]
+            bool includeNestedTypes = false,
+
+            [Description("Whether to format the output JSON with indentation for readability. Default: false.")]
+            bool writeIndented = false
+        )
+        {
+            var type = TypeUtils.GetType(typeName);
+            if (type == null)
+                throw new ArgumentException($"Type '{typeName}' not found in any loaded assembly. " +
+                    "Use the full type name including namespace (e.g. 'UnityEngine.Vector3').", nameof(typeName));
+
+            var reflector = UnityCopilotPluginEditor.Instance.Reflector ?? throw new Exception("Reflector is not available.");
+
+            var schema = reflector.GetSchema(type);
+            if (schema is JsonObject jsonObj)
+            {
+                // Root type-level description
+                if (descriptionMode == DescriptionMode.Ignore)
+                    jsonObj.Remove(JsonSchema.Description);
+
+                if (!includeNestedTypes)
+                    jsonObj.Remove(JsonSchema.Defs);
+                else
+                {
+                    if (jsonObj.TryGetPropertyValue(JsonSchema.Defs, out var defsNode) &&
+                        defsNode is JsonObject defsObj)
+                    {
+                        foreach (var def in defsObj)
+                        {
+                            if (def.Value is not JsonObject defObj)
+                                continue;
+
+                            // $defs entry type description: only kept when IncludeRecursively
+                            if (descriptionMode != DescriptionMode.IncludeRecursively)
+                                defObj.Remove(JsonSchema.Description);
+
+                            // $defs entry property/items descriptions: only kept when IncludeRecursively
+                            if (propertyDescriptionMode != DescriptionMode.IncludeRecursively)
+                            {
+                                if (defObj.TryGetPropertyValue(JsonSchema.Properties, out var defPropsNode) &&
+                                    defPropsNode is JsonObject defPropsObj)
+                                {
+                                    foreach (var prop in defPropsObj)
+                                    {
+                                        if (prop.Value is JsonObject propObj)
+                                            propObj.Remove(JsonSchema.Description);
+                                    }
+                                }
+                                if (defObj.TryGetPropertyValue(JsonSchema.Items, out var defItemsNode) &&
+                                    defItemsNode is JsonObject defItemsObj)
+                                {
+                                    defItemsObj.Remove(JsonSchema.Description);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Root property/items descriptions
+                if (propertyDescriptionMode == DescriptionMode.Ignore)
+                {
+                    if (jsonObj.TryGetPropertyValue(JsonSchema.Properties, out var propertiesNode) &&
+                        propertiesNode is JsonObject propertiesObj)
+                    {
+                        foreach (var prop in propertiesObj)
+                        {
+                            if (prop.Value is JsonObject propObj)
+                                propObj.Remove(JsonSchema.Description);
+                        }
+                    }
+                    if (jsonObj.TryGetPropertyValue(JsonSchema.Items, out var itemsNode) &&
+                        itemsNode is JsonObject itemsObj)
+                    {
+                        itemsObj.Remove(JsonSchema.Description);
+                    }
+                }
+            }
+            return schema.ToJsonString(new JsonSerializerOptions
+            {
+                WriteIndented = writeIndented,
+                TypeInfoResolver = new DefaultJsonTypeInfoResolver()
+            });
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/Type.GetJsonSchema.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8f371fa8564c404b97c535a1ede871fc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/Type.ListMembers.cs

@@ -0,0 +1,243 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json;
+using com.AtelierAI.Uco.Framework;
+using com.IvanMurzak.ReflectorNet.Utils;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.API
+{
+    public partial class Tool_Type
+    {
+        public const string TypeListMembersToolId = "type-list-members";
+        [UcoTool
+        (
+            TypeListMembersToolId,
+            Title = "Type / List Members",
+            ReadOnlyHint = true,
+            DestructiveHint = false,
+            IdempotentHint = true,
+            Enabled = true
+        )]
+        [UcoSkillDescription("List the members of a C# type (methods, properties, fields, events, constructors) " +
+            "by reflection across all loaded assemblies. Verify what a type actually exposes in THIS Unity version " +
+            "before calling it via script-execute / reflection-method-call.")]
+        [UcoSkillBody("List the members of a C# type via reflection — the way to verify your knowledge of an API " +
+            "against the ACTUAL loaded assembly (LLM training data can lag the installed Unity version, and packages add members).\n\n" +
+            "## Inputs\n\n" +
+            "- `typeName` — full type name preferred (e.g. `UnityEngine.Camera`, `UnityEditor.EditorGUILayout`). Simple names work when unambiguous.\n" +
+            "- `memberKinds` (default `All`) — comma-separated subset: `Method,Property,Field,Event,Constructor`.\n" +
+            "- `includeInherited` (default `true`) — `false` for members declared only on this exact type.\n" +
+            "- `publicOnly` (default `false`) — `true` to hide non-public members.\n" +
+            "- `maxResults` (default `200`) — cap to keep the response manageable; `0` = no limit.\n\n" +
+            "## Output\n\n" +
+            "JSON: `{ type, count, totalFound, truncated, members[] }`. Each member has `kind`, `name`, `isStatic`, `isPublic`, plus " +
+            "`returnType`+`params[]` (methods/constructors), `memberType`+`canRead`+`canWrite` (properties), or `memberType` (fields/events). " +
+            "Use it to confirm a member exists and its exact signature BEFORE invoking via script-execute or reflection-method-call.")]
+        [Description("List the members of a C# type by reflection (methods/properties/fields/events/constructors) with signatures. " +
+            "Use to verify what a type exposes in the current Unity version before calling it.")]
+        public string ListMembers
+        (
+            [Description("Full C# type name. Examples: 'UnityEngine.Camera', 'UnityEditor.AssetDatabase', 'UnityEngine.Rigidbody'. " +
+                "Simple names like 'Camera' work when unambiguous.")]
+            string typeName,
+
+            [Description("Comma-separated member kinds to include: 'Method', 'Property', 'Field', 'Event', 'Constructor', or 'All' (default). " +
+                "Example: 'Property,Field'.")]
+            string memberKinds = "All",
+
+            [Description("Include inherited members (default true). Set false to see only members declared on this exact type.")]
+            bool includeInherited = true,
+
+            [Description("Only list public members (default false; non-public members are included).")]
+            bool publicOnly = false,
+
+            [Description("Maximum members to return (default 200). 0 = no limit. Truncation is reported in the output.")]
+            int maxResults = 200,
+
+            [Description("Pretty-print the JSON output (default false).")]
+            bool writeIndented = false
+        )
+        {
+            var type = TypeUtils.GetType(typeName);
+            if (type == null)
+                throw new ArgumentException($"Type '{typeName}' not found in any loaded assembly. " +
+                    "Use the full type name including namespace (e.g. 'UnityEngine.Camera').", nameof(typeName));
+
+            var kinds = ParseMemberKinds(memberKinds);
+            bool want(string k) => kinds.Contains("ALL") || kinds.Contains(k);
+
+            // Public|NonPublic|Instance|Static gives the full surface; DeclaredOnly drops inherited.
+            var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
+            if (!includeInherited)
+                flags |= BindingFlags.DeclaredOnly;
+
+            var members = new List<object>();
+
+            if (want("Method"))
+            {
+                foreach (var m in type.GetMethods(flags))
+                {
+                    if (m.IsSpecialName) continue; // property get/set, operators, event add/remove
+                    if (publicOnly && !m.IsPublic) continue;
+                    members.Add(new
+                    {
+                        kind = "Method",
+                        name = m.Name,
+                        returnType = FriendlyTypeName(m.ReturnType),
+                        isStatic = m.IsStatic,
+                        isPublic = m.IsPublic,
+                        @params = m.GetParameters()
+                            .Select(p => new { name = p.Name, type = FriendlyTypeName(p.ParameterType) })
+                            .ToArray(),
+                    });
+                }
+            }
+
+            if (want("Property"))
+            {
+                foreach (var p in type.GetProperties(flags))
+                {
+                    var getter = p.GetMethod;
+                    var setter = p.SetMethod;
+                    var isPublic = (getter != null && getter.IsPublic) || (setter != null && setter.IsPublic);
+                    if (publicOnly && !isPublic) continue;
+                    members.Add(new
+                    {
+                        kind = "Property",
+                        name = p.Name,
+                        memberType = FriendlyTypeName(p.PropertyType),
+                        isStatic = (getter != null && getter.IsStatic) || (setter != null && setter.IsStatic),
+                        isPublic = isPublic,
+                        canRead = p.CanRead,
+                        canWrite = p.CanWrite,
+                    });
+                }
+            }
+
+            if (want("Field"))
+            {
+                foreach (var f in type.GetFields(flags))
+                {
+                    if (f.IsSpecialName) continue; // compiler-generated backing fields
+                    if (publicOnly && !f.IsPublic) continue;
+                    members.Add(new
+                    {
+                        kind = "Field",
+                        name = f.Name,
+                        memberType = FriendlyTypeName(f.FieldType),
+                        isStatic = f.IsStatic,
+                        isPublic = f.IsPublic,
+                        isReadonly = f.IsInitOnly || f.IsLiteral,
+                    });
+                }
+            }
+
+            if (want("Event"))
+            {
+                foreach (var e in type.GetEvents(flags))
+                {
+                    var add = e.GetAddMethod(nonPublic: true);
+                    if (publicOnly && add != null && !add.IsPublic) continue;
+                    members.Add(new
+                    {
+                        kind = "Event",
+                        name = e.Name,
+                        memberType = FriendlyTypeName(e.EventHandlerType),
+                        isStatic = add != null && add.IsStatic,
+                        isPublic = add == null || add.IsPublic,
+                    });
+                }
+            }
+
+            if (want("Constructor"))
+            {
+                foreach (var c in type.GetConstructors(flags))
+                {
+                    if (publicOnly && !c.IsPublic) continue;
+                    members.Add(new
+                    {
+                        kind = "Constructor",
+                        name = type.Name,
+                        isStatic = c.IsStatic,
+                        isPublic = c.IsPublic,
+                        @params = c.GetParameters()
+                            .Select(p => new { name = p.Name, type = FriendlyTypeName(p.ParameterType) })
+                            .ToArray(),
+                    });
+                }
+            }
+
+            var totalFound = members.Count;
+            var truncated = maxResults > 0 && totalFound > maxResults;
+            if (maxResults > 0 && totalFound > maxResults)
+                members = members.Take(maxResults).ToList();
+
+            var resultObj = new
+            {
+                type = type.FullName,
+                count = members.Count,
+                totalFound = totalFound,
+                truncated = truncated,
+                members = members,
+            };
+            return JsonSerializer.Serialize(resultObj, new JsonSerializerOptions
+            {
+                WriteIndented = writeIndented,
+            });
+        }
+
+        static HashSet<string> ParseMemberKinds(string? memberKinds)
+        {
+            var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            if (string.IsNullOrWhiteSpace(memberKinds))
+            {
+                set.Add("ALL");
+                return set;
+            }
+            foreach (var part in memberKinds.Split(','))
+            {
+                var k = part.Trim();
+                if (k.Length > 0)
+                    set.Add(k.ToUpperInvariant());
+            }
+            if (set.Count == 0)
+                set.Add("ALL");
+            return set;
+        }
+
+        // Render a runtime Type as a readable, callable name: keeps namespace, renders generics
+        // as `Ns.G<T>` (not the CLR `Ns.G`1[[T, …]]`) and arrays as `T[]`.
+        static string FriendlyTypeName(Type? t)
+        {
+            if (t == null) return "null";
+            if (t.IsArray) return FriendlyTypeName(t.GetElementType()) + "[]";
+            if (t.IsByRef) return FriendlyTypeName(t.GetElementType());
+            if (t.IsGenericParameter) return t.Name;
+            if (t.IsGenericType)
+            {
+                var def = t.IsGenericTypeDefinition ? t : t.GetGenericTypeDefinition();
+                var baseName = def.FullName ?? def.Name;
+                var tick = baseName.IndexOf('`');
+                if (tick >= 0) baseName = baseName.Substring(0, tick);
+                var args = string.Join(", ", t.GetGenericArguments().Select(FriendlyTypeName));
+                return $"{baseName}<{args}>";
+            }
+            return t.FullName ?? t.Name;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/Type.ListMembers.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6bbf413e0d2d1504e9fcb3969232ff54
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/Type.cs

@@ -0,0 +1,39 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using com.AtelierAI.Uco.Framework;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.API
+{
+    [UcoToolType]
+    public partial class Tool_Type
+    {
+        public enum DescriptionMode
+        {
+            /// <summary>
+            /// Include descriptions on the target type and its direct properties/items.
+            /// Descriptions inside <c>$defs</c> entries are excluded.
+            /// </summary>
+            Include,
+
+            /// <summary>
+            /// Include descriptions everywhere: the target type, its properties/items,
+            /// and recursively inside all <c>$defs</c> entries.
+            /// </summary>
+            IncludeRecursively,
+
+            /// <summary>
+            /// Omit all <c>description</c> fields from the schema output.
+            /// </summary>
+            Ignore
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/API/Tool/Type.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 61fcaa13347d448eb89e086b41438e15
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant: