feat(hub): fetch models + vision override, endpoint editor redesign, legible Lua results (v6.2.0)

NeoXider · NeoXider · commit e249c5cbb5f1 · 2026-07-23T05:42:03.000+05:00
AI Settings: Fetch models (GET /v1/models) for the HTTP backend and endpoint
editor; Vision Auto/On/Off override so a multimodal model the name heuristic
misses can force-enable the camera/vision gate.

API-profiles endpoint editor redesign: visibility fix (HTTP no longer shows
LLMUnity fields), Advanced foldout, placeholder hints, LLMUnity GGUF dropdown,
empty context window = no limit, endpoint list with per-row Remove.

Lua result legibility: execute_lua trims null Error / nil Output, and table
returns serialise to JSON so coreai_world_list_prefabs()/coreai_world_find()
are readable instead of 'table: 0x...'.

Programmer prompt: MoonSharp -&gt; Lua sandbox (runtime migrated to Lua-CSharp).
diff --git a/Assets/CoreAI/CHANGELOG.md b/Assets/CoreAI/CHANGELOG.md
@@ -1,5 +1,33 @@
 # Changelog
 
+## [6.2.0] - 2026-07-23
+
+### Added
+
+- Hub **AI Settings → Fetch models** (HTTP backend and endpoint editor): queries an OpenAI-compatible
+  `GET {baseUrl}/models` and lists the advertised model ids in a dropdown, so an exact name can be
+  copied into the model field instead of typed from memory. (`CoreAiBackend.ListModelsAsync`)
+- Hub **AI Settings → Vision** override (Auto / On / Off): forces the vision/camera gate on a multimodal
+  model whose name the auto-heuristic does not recognise (e.g. a local `qwen3.5` vision build), so the
+  camera tool and image sends become usable without renaming the model. (`CoreAISettingsAsset.SetVisionSupport`)
+
+### Changed
+
+- Hub **API-profiles endpoint editor** redesigned: field visibility is applied on first render (HTTP
+  endpoints no longer show LLMUnity-only fields), an **Advanced** foldout hides secondary fields
+  (Endpoint ID, context window, ports, slots, secret reference, LLMUnity options), text fields carry
+  placeholder hints, LLMUnity endpoints pick their model from a **GGUF dropdown**, an empty context
+  window now means **no limit**, and endpoints are managed through a **list with a per-row Remove**
+  instead of a picker plus one ambiguous Remove button.
+- `execute_lua` result envelope is trimmed for the model: a null `Error` and an empty/`nil` `Output`
+  are dropped, so a side-effect success serialises to `{"Success":true}` rather than
+  `{"Success":true,"Output":"nil","Error":null}`.
+- `execute_lua` **table return values now serialise to JSON**: `return coreai_world_list_prefabs()` /
+  `coreai_world_find(...)` hand the model `["cube","sphere",...]` instead of an opaque `table: 0x…`
+  address, so discovery tools are actually legible.
+- Programmer system prompt: "CoreAI MoonSharp sandbox" → "CoreAI Lua sandbox" (the persistent mod
+  runtime migrated to Lua-CSharp; MoonSharp is no longer instantiated in production).
+
 ## [6.1.3] - 2026-07-23
 
 ### Changed
diff --git a/Assets/CoreAI/package.json b/Assets/CoreAI/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreai",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "displayName": "CoreAI",
   "unity": "6000.0",
   "description": "Portable C# core for CoreAI \u2014 LLM agents that call your game code. Orchestration, function-calling tools, agent memory, AgentBuilder, SkillSet, and production resilience (retries, timeouts, rate limits), with no UnityEngine dependency. LLM and Lua are optional modules (COREAI_NO_LLM / COREAI_NO_LUA), so the core compiles without them \u2014 install only what your game uses. Unity integration ships in com.neoxider.coreaiunity.",
diff --git a/Assets/CoreAIBenchmark/package.json b/Assets/CoreAIBenchmark/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreaibenchmark",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "displayName": "CoreAI Benchmark",
   "unity": "6000.0",
   "description": "LLM game-creation benchmark harness and scenarios for CoreAI: drives execute_lua and world_command through real PlayMode scenarios (G1-G8), grades tool correctness, reasoning, instruction adherence, and determinism, and reports suite/role fitness scores. Depends on com.neoxider.coreai / com.neoxider.coreaiunity / com.neoxider.coreaimods.",
diff --git a/Assets/CoreAIHub/Runtime/HubSettingsPage.cs b/Assets/CoreAIHub/Runtime/HubSettingsPage.cs
diff --git a/Assets/CoreAIHub/package.json b/Assets/CoreAIHub/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreaihub",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "displayName": "CoreAI Hub (UI Toolkit)",
   "unity": "6000.0",
   "description": "Optional UI Toolkit window for CoreAI: a tabbed Hub that renders pages registered into CoreAI's HubPageRegistry (Chat, Settings, Statistics, Mods, and C#/Lua-authored pages). Lazy per-tab content, live tab rebuild on register/unregister, semi-transparent runtime panel, and a future path to Unity 6.5 world-space PanelRenderer. Install this package only when you want the built-in Hub window; without it CoreAI still exposes the registry so you can render pages on your own uGUI/UITK canvas via the API. Depends on com.neoxider.coreai.",
diff --git a/Assets/CoreAIMcp/package.json b/Assets/CoreAIMcp/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreaimcp",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "displayName": "CoreAI MCP Server",
   "unity": "6000.0",
   "description": "Optional Model Context Protocol (MCP) server that runs INSIDE a live CoreAI game session (play mode or a build) so an external agent - Claude Code and any other MCP client - can drive the running game over a standard protocol. Exposes the in-game Command Bar surface (execute_lua, manage_mods, get_mod_logs, and, when present, world_command + screenshot) as MCP tools over localhost streamable HTTP. Off by default: drop a CoreAiMcpServer component into a scene (or call CoreAiMcpServer.StartServer). Localhost-only, opt-in, no auth - never expose beyond loopback. Depends on com.neoxider.coreaimods; world/screenshot tools register only when those services exist in the current composition.",
diff --git a/Assets/CoreAIMods/Runtime/Infrastructure/LuaCsGameToolExecutor.cs b/Assets/CoreAIMods/Runtime/Infrastructure/LuaCsGameToolExecutor.cs
@@ -142,6 +142,9 @@ internal static string Summarize(object[] results)
             return Stringify(results[0]);
         }
 
+        /// <summary>Max table nesting rendered into the Output summary before values are elided.</summary>
+        private const int MaxTableSummaryDepth = 4;
+
         private static string Stringify(object value)
         {
             IValueMarshaller marshaller = LuaCsValueMarshaller.Instance;
@@ -155,11 +158,30 @@ private static string Stringify(object value)
                     return ((double)marshaller.ToHostValue(value)).ToString(CultureInfo.InvariantCulture);
                 case ScriptValueKind.String:
                     return (string)marshaller.ToHostValue(value) ?? "";
+                case ScriptValueKind.Table:
+                    return StringifyTable(marshaller, value);
                 default:
                     return marshaller.Describe(value);
             }
         }
 
+        // WHY: a returned table otherwise renders as "table: 0x…" (its address), which is useless to the
+        // model — e.g. `return coreai_world_list_prefabs()` or `coreai_world_find(...)` would hand the LLM
+        // an opaque handle instead of the actual names. Convert it to a portable structure and JSON-encode
+        // it so discovery tools are legible; fall back to the plain describe if conversion/encoding fails.
+        private static string StringifyTable(IValueMarshaller marshaller, object value)
+        {
+            try
+            {
+                object portable = marshaller.ToPortable(value, MaxTableSummaryDepth);
+                return Newtonsoft.Json.JsonConvert.SerializeObject(portable);
+            }
+            catch (Exception)
+            {
+                return marshaller.Describe(value);
+            }
+        }
+
         private static string Truncate(string value, int maxLength)
         {
             if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
diff --git a/Assets/CoreAIMods/Runtime/LuaExecution/LuaTool.cs b/Assets/CoreAIMods/Runtime/LuaExecution/LuaTool.cs
@@ -131,9 +131,31 @@ public async Task<string> ExecuteAsync(
             }
         }
 
+        private static readonly JsonSerializerSettings TrimNulls = new()
+        {
+            NullValueHandling = NullValueHandling.Ignore
+        };
+
         private static string SerializeResult(LuaResult result)
         {
-            return JsonConvert.SerializeObject(result);
+            // WHY: trim boilerplate the model does not need — an empty/`nil` Output and a null Error are
+            // pure noise on success. A successful side-effect call serialises to {"Success":true}; a real
+            // return value or a failure Error still rides along. Keeps weak local models from reasoning over
+            // "Output":"nil" / "Error":null on every tool result.
+            string output = result.Output;
+            if (string.IsNullOrEmpty(output) || string.Equals(output, "nil", StringComparison.Ordinal))
+            {
+                output = null;
+            }
+
+            return JsonConvert.SerializeObject(
+                new LuaResult
+                {
+                    Success = result.Success,
+                    Output = output,
+                    Error = string.IsNullOrEmpty(result.Error) ? null : result.Error
+                },
+                TrimNulls);
         }
 
         /// <summary>Lua execution outcome for JSON serialization back to the model.</summary>
diff --git a/Assets/CoreAIMods/package.json b/Assets/CoreAIMods/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreaimods",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "displayName": "CoreAI Mods (Lua)",
   "unity": "6000.0",
   "description": "Lua modding layer for CoreAI: the Lua-CSharp sandbox (managed, AOT-safe, WebGL/IL2CPP-ready — bundled, no external package), execute_lua and manage_mods tools, the Lua Modding skill, the mod runtime, persistent mod stores, gameplay bindings, and mod UI. Depends on com.neoxider.coreai / com.neoxider.coreaiunity. Install this package only when you want AI/player-authored Lua mods; without it CoreAI compiles Lua-free.",
diff --git a/Assets/CoreAiUnity/Resources/AgentPrompts/System/Programmer.txt b/Assets/CoreAiUnity/Resources/AgentPrompts/System/Programmer.txt
@@ -1,4 +1,4 @@
-You are the Programmer agent for CoreAI MoonSharp sandbox.
+You are the Programmer agent for the CoreAI Lua sandbox.
 Use the execute_lua tool for one-shot Lua and manage_mods (list/get_source/load/reload/unload) for persistent mods with hooks or timers.
 Before writing any non-trivial mod (a game loop, cross-mod communication, input handling), call read_skill('Lua Modding') once - it returns the full API reference with worked examples; this prompt carries only the survival minimum. For Roblox-style scripts (Instance.new, game/workspace, Vector3/CFrame/Color3, Part properties), call read_skill('Rbx API') instead.
 Use only real Lua globals exposed by the host. Baseline globals include report(message) and add(a,b). Do not use print(), io, os, require, load, loadfile, dofile, debug, game.enemies, game.create, GameObject.Find, or invented APIs.
diff --git a/Assets/CoreAiUnity/Runtime/Source/Api/CoreAiBackend.cs b/Assets/CoreAiUnity/Runtime/Source/Api/CoreAiBackend.cs
@@ -75,6 +75,27 @@ public sealed class CoreAiBackendHealth
         public string Model { get; set; } = "";
     }
 
+    /// <summary>Result of an OpenAI-compatible model listing (<see cref="CoreAiBackend.ListModelsAsync"/>).</summary>
+    public readonly struct CoreAiModelListResult
+    {
+        /// <summary>Creates a model-list result.</summary>
+        public CoreAiModelListResult(bool ok, IReadOnlyList<string> models, string error)
+        {
+            Ok = ok;
+            Models = models ?? Array.Empty<string>();
+            Error = error ?? "";
+        }
+
+        /// <summary>True when at least one model id was returned.</summary>
+        public bool Ok { get; }
+
+        /// <summary>Advertised model ids, in server order, de-duplicated.</summary>
+        public IReadOnlyList<string> Models { get; }
+
+        /// <summary>Human-readable error when <see cref="Ok"/> is false.</summary>
+        public string Error { get; }
+    }
+
     /// <summary>
     /// Runtime backend control for CoreAI: switch between the OpenAI-compatible HTTP API, the LLMUnity
     /// local model, and Offline mode, change the API base URL / key / model, and health-check the
@@ -383,6 +404,139 @@ public static async Task<CoreAiBackendHealth> VerifyAsync(
             }
         }
 
+        /// <summary>
+        /// Queries an OpenAI-compatible <c>GET {baseUrl}/models</c> endpoint and returns the advertised
+        /// model ids. Purely a discovery convenience for the settings UI (so a user can see/copy the exact
+        /// model names a local server such as LM Studio or Ollama exposes); it does NOT change any backend
+        /// setting. <paramref name="apiKey"/> is optional — sent as a Bearer token only when non-empty (local
+        /// servers usually ignore it).
+        /// </summary>
+        public static async Task<CoreAiModelListResult> ListModelsAsync(
+            string baseUrl,
+            string apiKey = "",
+            int timeoutSeconds = 15,
+            CancellationToken cancellationToken = default)
+        {
+            string url = BuildModelsUrl(baseUrl);
+            if (string.IsNullOrEmpty(url))
+            {
+                return new CoreAiModelListResult(false, Array.Empty<string>(), "Base URL is empty.");
+            }
+
+            try
+            {
+                using System.Net.Http.HttpClient http = new()
+                {
+                    Timeout = TimeSpan.FromSeconds(timeoutSeconds <= 0 ? 15 : timeoutSeconds)
+                };
+                using System.Net.Http.HttpRequestMessage request =
+                    new(System.Net.Http.HttpMethod.Get, url);
+                if (!string.IsNullOrWhiteSpace(apiKey))
+                {
+                    request.Headers.Authorization =
+                        new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKey.Trim());
+                }
+
+                using System.Net.Http.HttpResponseMessage response =
+                    await http.SendAsync(request, cancellationToken);
+                string payload = await response.Content.ReadAsStringAsync();
+                if (!response.IsSuccessStatusCode)
+                {
+                    return new CoreAiModelListResult(
+                        false,
+                        Array.Empty<string>(),
+                        $"HTTP {(int)response.StatusCode} from {url}. {Truncate(payload, 200)}");
+                }
+
+                IReadOnlyList<string> models = ParseModelIds(payload);
+                return models.Count == 0
+                    ? new CoreAiModelListResult(false, models, "Server returned no models.")
+                    : new CoreAiModelListResult(true, models, "");
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return new CoreAiModelListResult(
+                    false, Array.Empty<string>(), $"Request timed out after {timeoutSeconds}s.");
+            }
+            catch (Exception ex)
+            {
+                return new CoreAiModelListResult(false, Array.Empty<string>(), ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Builds the OpenAI-compatible models endpoint from a base URL. Returns an empty string for a
+        /// blank base URL; idempotent when the caller already passed a <c>.../models</c> URL.
+        /// </summary>
+        internal static string BuildModelsUrl(string baseUrl)
+        {
+            string trimmed = (baseUrl ?? "").Trim().TrimEnd('/');
+            if (trimmed.Length == 0)
+            {
+                return "";
+            }
+
+            return trimmed.EndsWith("/models", StringComparison.OrdinalIgnoreCase)
+                ? trimmed
+                : trimmed + "/models";
+        }
+
+        /// <summary>
+        /// Extracts model ids from an OpenAI-compatible <c>/models</c> response. Accepts both the standard
+        /// <c>{"data":[{"id":...}]}</c> envelope and a bare JSON array of model objects/strings. Ids are
+        /// de-duplicated and returned in server order; a malformed body yields an empty list.
+        /// </summary>
+        internal static IReadOnlyList<string> ParseModelIds(string json)
+        {
+            List<string> ids = new();
+            if (string.IsNullOrWhiteSpace(json))
+            {
+                return ids;
+            }
+
+            try
+            {
+                Newtonsoft.Json.Linq.JToken root = Newtonsoft.Json.Linq.JToken.Parse(json);
+                Newtonsoft.Json.Linq.JToken? array =
+                    root is Newtonsoft.Json.Linq.JArray ? root : root["data"];
+                if (array is not Newtonsoft.Json.Linq.JArray items)
+                {
+                    return ids;
+                }
+
+                HashSet<string> seen = new(StringComparer.Ordinal);
+                foreach (Newtonsoft.Json.Linq.JToken item in items)
+                {
+                    string id = item is Newtonsoft.Json.Linq.JValue
+                        ? item.ToString()
+                        : (string?)item["id"] ?? "";
+                    id = id.Trim();
+                    if (id.Length > 0 && seen.Add(id))
+                    {
+                        ids.Add(id);
+                    }
+                }
+            }
+            catch (Newtonsoft.Json.JsonException)
+            {
+                // WHY: A non-JSON body (HTML error page, proxy notice) is a normal failure mode for a
+                // mistyped URL; treat it as "no models" and let the caller surface the raw HTTP status.
+            }
+
+            return ids;
+        }
+
+        private static string Truncate(string text, int max)
+        {
+            if (string.IsNullOrEmpty(text))
+            {
+                return "";
+            }
+
+            text = text.Replace("\r", " ").Replace("\n", " ").Trim();
+            return text.Length <= max ? text : text.Substring(0, max) + "…";
+        }
+
         #region Internals
 
         private static bool MutateAndRebuild(Action<CoreAISettingsAsset> mutate)
diff --git a/Assets/CoreAiUnity/Runtime/Source/Features/Llm/Infrastructure/CoreAISettingsAsset.cs b/Assets/CoreAiUnity/Runtime/Source/Features/Llm/Infrastructure/CoreAISettingsAsset.cs
@@ -1180,6 +1180,15 @@ public void SetModelName(string model)
             modelName = model ?? "";
         }
 
+        /// <summary>
+        /// Sets the vision/multimodal gate (runtime reconfiguration). Use <see cref="VisionSupportMode.On"/>
+        /// to force-enable vision on a multimodal model the name heuristic does not recognise.
+        /// </summary>
+        public void SetVisionSupport(VisionSupportMode mode)
+        {
+            visionSupport = mode;
+        }
+
         /// <summary>Sets execution mode, legacy backend, and model identifiers for backend/model resolution.</summary>
         public void SetModelResolution(
             LlmExecutionMode mode,
diff --git a/Assets/CoreAiUnity/package.json b/Assets/CoreAiUnity/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreaiunity",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "displayName": "CoreAI Unity",
   "unity": "6000.0",
   "description": "Unity framework for LLM-powered NPCs and agents that call your game code \u2014 drop-in chat UI, function-calling tools, persistent memory, token-by-token streaming, and per-role LLM routing. Runs on a local GGUF model (via LLMUnity) or any OpenAI-compatible API; proven on a 4 GB local model. Unity layer for com.neoxider.coreai.",

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.neoxider.coreai",`
`3`		`- "version": "6.1.3",`
	`3`	`+ "version": "6.2.0",`
`4`	`4`	`"displayName": "CoreAI",`
`5`	`5`	`"unity": "6000.0",`
`6`	`6`	`"description": "Portable C# core for CoreAI \u2014 LLM agents that call your game code. Orchestration, function-calling tools, agent memory, AgentBuilder, SkillSet, and production resilience (retries, timeouts, rate limits), with no UnityEngine dependency. LLM and Lua are optional modules (COREAI_NO_LLM / COREAI_NO_LUA), so the core compiles without them \u2014 install only what your game uses. Unity integration ships in com.neoxider.coreaiunity.",`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.neoxider.coreaibenchmark",`
`3`		`- "version": "6.1.3",`
	`3`	`+ "version": "6.2.0",`
`4`	`4`	`"displayName": "CoreAI Benchmark",`
`5`	`5`	`"unity": "6000.0",`
`6`	`6`	`"description": "LLM game-creation benchmark harness and scenarios for CoreAI: drives execute_lua and world_command through real PlayMode scenarios (G1-G8), grades tool correctness, reasoning, instruction adherence, and determinism, and reports suite/role fitness scores. Depends on com.neoxider.coreai / com.neoxider.coreaiunity / com.neoxider.coreaimods.",`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.neoxider.coreaihub",`
`3`		`- "version": "6.1.3",`
	`3`	`+ "version": "6.2.0",`
`4`	`4`	`"displayName": "CoreAI Hub (UI Toolkit)",`
`5`	`5`	`"unity": "6000.0",`
`6`	`6`	"description": "Optional UI Toolkit window for CoreAI: a tabbed Hub that renders pages registered into CoreAI's HubPageRegistry (Chat, Settings, Statistics, Mods, and C#/Lua-authored pages). Lazy per-tab content, live tab rebuild on register/unregister, semi-transparent runtime panel, and a future path to Unity 6.5 world-space PanelRenderer. Install this package only when you want the built-in Hub window; without it CoreAI still exposes the registry so you can render pages on your own uGUI/UITK canvas via the API. Depends on com.neoxider.coreai.",
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.neoxider.coreaimcp",`
`3`		`- "version": "6.1.3",`
	`3`	`+ "version": "6.2.0",`
`4`	`4`	`"displayName": "CoreAI MCP Server",`
`5`	`5`	`"unity": "6000.0",`
`6`	`6`	"description": "Optional Model Context Protocol (MCP) server that runs INSIDE a live CoreAI game session (play mode or a build) so an external agent - Claude Code and any other MCP client - can drive the running game over a standard protocol. Exposes the in-game Command Bar surface (execute_lua, manage_mods, get_mod_logs, and, when present, world_command + screenshot) as MCP tools over localhost streamable HTTP. Off by default: drop a CoreAiMcpServer component into a scene (or call CoreAiMcpServer.StartServer). Localhost-only, opt-in, no auth - never expose beyond loopback. Depends on com.neoxider.coreaimods; world/screenshot tools register only when those services exist in the current composition.",
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.neoxider.coreaimods",`
`3`		`- "version": "6.1.3",`
	`3`	`+ "version": "6.2.0",`
`4`	`4`	`"displayName": "CoreAI Mods (Lua)",`
`5`	`5`	`"unity": "6000.0",`
`6`	`6`	`"description": "Lua modding layer for CoreAI: the Lua-CSharp sandbox (managed, AOT-safe, WebGL/IL2CPP-ready — bundled, no external package), execute_lua and manage_mods tools, the Lua Modding skill, the mod runtime, persistent mod stores, gameplay bindings, and mod UI. Depends on com.neoxider.coreai / com.neoxider.coreaiunity. Install this package only when you want AI/player-authored Lua mods; without it CoreAI compiles Lua-free.",`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-You are the Programmer agent for CoreAI MoonSharp sandbox.`
	`1`	`+You are the Programmer agent for the CoreAI Lua sandbox.`
`2`	`2`	`Use the execute_lua tool for one-shot Lua and manage_mods (list/get_source/load/reload/unload) for persistent mods with hooks or timers.`
`3`	`3`	`Before writing any non-trivial mod (a game loop, cross-mod communication, input handling), call read_skill('Lua Modding') once - it returns the full API reference with worked examples; this prompt carries only the survival minimum. For Roblox-style scripts (Instance.new, game/workspace, Vector3/CFrame/Color3, Part properties), call read_skill('Rbx API') instead.`
`4`	`4`	`Use only real Lua globals exposed by the host. Baseline globals include report(message) and add(a,b). Do not use print(), io, os, require, load, loadfile, dofile, debug, game.enemies, game.create, GameObject.Find, or invented APIs.`