Fix single-quoted timezone examples in schemas and add lenient JSON argument parser

- Replace single-quoted IANA examples ('America/Chicago') with backtick notation
  in all tool Description attributes so LLMs don't echo back single quotes
- TryGetTimeZone now strips surrounding single quotes or backticks before lookup
  as a defensive fallback for LLMs that still echo the old style
- Add ToolArgumentParser utility with NormalizeSingleQuotedJson and
  ParseArguments<T> for lenient parsing of JS-style single-quoted JSON objects

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: rockfordlhotka

src/CalendarMcp.Core/Tools/CreateEventTool.cs

@@ -15,7 +15,7 @@ public sealed class CreateEventTool(
     IProviderServiceFactory providerFactory,
     ILogger<CreateEventTool> logger)
 {
-    [McpServerTool, Description("Create a calendar event. Always pass the timeZone parameter using the user's local IANA timezone (e.g. 'America/Chicago', 'America/New_York', 'Europe/London') so events are created at the correct local time. Requires explicit account selection or smart routing.")]
+    [McpServerTool, Description("Create a calendar event. Always pass the timeZone parameter using the user's local IANA timezone (e.g. `America/Chicago`, `America/New_York`, `Europe/London`) so events are created at the correct local time. Requires explicit account selection or smart routing.")]
     public async Task<string> CreateEvent(
         [Description("Event subject/title")] string subject,
         [Description("Event start date and time (ISO 8601 format)")] DateTime start,
@@ -25,7 +25,7 @@ public async Task<string> CreateEvent(
         [Description("Event location")] string? location = null,
         [Description("List of attendee email addresses")] List<string>? attendees = null,
         [Description("Event description/body")] string? body = null,
-        [Description("IANA timezone name for the event (e.g. 'America/Chicago', 'America/New_York', 'Europe/London'). Required to create events at the correct local time.")] string? timeZone = null)
+        [Description("IANA timezone name for the event (e.g. `America/Chicago`, `America/New_York`, `Europe/London`). Required to create events at the correct local time.")] string? timeZone = null)
     {
         // Strip CDATA wrappers if present (LLMs sometimes wrap content in XML CDATA)
         body = StripCdataWrapper(body);

src/CalendarMcp.Core/Tools/GetCalendarEventDetailsTool.cs

@@ -19,7 +19,7 @@ public sealed class GetCalendarEventDetailsTool(
 {
     [McpServerTool, Description("Get full details for a single calendar event including attendee responses, free/busy status, recurrence pattern, and online meeting link. Use this after get_calendar_events to fetch richer data for a specific event.")]
     public async Task<string> GetCalendarEventDetails(
-        [Description("IANA timezone name for displaying event times (e.g. 'America/Chicago', 'America/New_York', 'Europe/London', 'Asia/Tokyo'). All event times are returned in both UTC and this local timezone.")] string timeZone,
+        [Description("IANA timezone name for displaying event times (e.g. `America/Chicago`, `America/New_York`, `Europe/London`, `Asia/Tokyo`). All event times are returned in both UTC and this local timezone.")] string timeZone,
         [Description("Account ID from get_calendar_events")] string accountId,
         [Description("Calendar ID from get_calendar_events, or 'primary' for the default calendar")] string calendarId,
         [Description("Event ID from get_calendar_events")] string eventId)

src/CalendarMcp.Core/Tools/GetCalendarEventsTool.cs

@@ -19,9 +19,9 @@ public sealed class GetCalendarEventsTool(
 {
     [McpServerTool, Description("Get calendar events for a date range from one or all accounts. The timeZone parameter is required. Returns events sorted by start time, each with: id, accountId, calendarId, subject, start/end in both UTC and local time, timezone, location, attendees, isAllDay, organizer. Use the returned accountId and id when calling delete_event, respond_to_event, or get_calendar_event_details.")]
     public async Task<string> GetCalendarEvents(
-        [Description("IANA timezone name for displaying event times (e.g. 'America/Chicago', 'America/New_York', 'Europe/London', 'Asia/Tokyo'). All event times are returned in both UTC and this local timezone. Required.")] string timeZone,
-        [Description("Start of the date range (ISO 8601 format, e.g. '2026-02-20'). Defaults to today.")] DateTime? startDate = null,
-        [Description("End of the date range (ISO 8601 format, e.g. '2026-02-27'). Defaults to 7 days after startDate.")] DateTime? endDate = null,
+        [Description("IANA timezone name for displaying event times (e.g. `America/Chicago`, `America/New_York`, `Europe/London`, `Asia/Tokyo`). All event times are returned in both UTC and this local timezone. Required.")] string timeZone,
+        [Description("Start of the date range (ISO 8601 format, e.g. `2026-02-20`). Defaults to today.")] DateTime? startDate = null,
+        [Description("End of the date range (ISO 8601 format, e.g. `2026-02-27`). Defaults to 7 days after startDate.")] DateTime? endDate = null,
         [Description("Account ID to query, or omit to query all accounts. Obtain from list_accounts.")] string? accountId = null,
         [Description("Calendar ID to query, or omit for all calendars. Obtain from list_calendars.")] string? calendarId = null,
         [Description("Maximum number of events to return per account (default 50)")] int count = 50)

src/CalendarMcp.Core/Utilities/TimeZoneHelper.cs

@@ -26,15 +26,23 @@ public static string ToLocalString(DateTimeOffset dto, TimeZoneInfo timeZone)
 
     /// <summary>
     /// Tries to find a TimeZoneInfo by IANA timezone ID. Returns null if invalid.
+    /// Strips surrounding single quotes or backticks that LLMs sometimes echo from schema examples.
     /// </summary>
     public static TimeZoneInfo? TryGetTimeZone(string? timeZoneId)
     {
         if (string.IsNullOrWhiteSpace(timeZoneId))
             return null;
 
+        var id = timeZoneId.Trim();
+
+        // Strip surrounding single quotes ('America/Chicago') or backticks (`America/Chicago`)
+        // that LLMs may echo verbatim from schema description examples.
+        if (id.Length >= 2 && id[0] == id[^1] && (id[0] == '\'' || id[0] == '`'))
+            id = id[1..^1].Trim();
+
         try
         {
-            return TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
+            return TimeZoneInfo.FindSystemTimeZoneById(id);
         }
         catch (TimeZoneNotFoundException)
         {

src/CalendarMcp.Core/Utilities/ToolArgumentParser.cs

@@ -0,0 +1,149 @@
+using System.Text;
+using System.Text.Json;
+
+namespace CalendarMcp.Core.Utilities;
+
+/// <summary>
+/// Helpers for parsing tool arguments that may arrive as JS-style (single-quoted) JSON
+/// rather than strict JSON, which some LLMs produce when they echo schema examples.
+/// </summary>
+public static class ToolArgumentParser
+{
+    /// <summary>
+    /// Deserializes a JSON string, falling back to lenient single-quoted JS normalization
+    /// if strict parsing fails.
+    /// </summary>
+    public static T? ParseArguments<T>(string json, JsonSerializerOptions? options = null)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+            return default;
+
+        // Strict parse first
+        try
+        {
+            return JsonSerializer.Deserialize<T>(json, options);
+        }
+        catch (JsonException) { }
+
+        // Lenient fallback: normalize single-quoted / unquoted-key JS syntax
+        var normalized = NormalizeSingleQuotedJson(json);
+        return JsonSerializer.Deserialize<T>(normalized, options);
+    }
+
+    /// <summary>
+    /// Converts a JS-style single-quoted or bare-key JSON string to strict JSON.
+    /// <list type="bullet">
+    ///   <item>Single-quoted strings: <c>'value'</c> → <c>"value"</c></item>
+    ///   <item>Unquoted object keys: <c>{key: 'v'}</c> → <c>{"key": "v"}</c></item>
+    ///   <item>Double-quotes inside single-quoted strings are escaped.</item>
+    /// </list>
+    /// Returns the input unchanged if it is already valid JSON.
+    /// </summary>
+    public static string NormalizeSingleQuotedJson(string input)
+    {
+        if (string.IsNullOrWhiteSpace(input))
+            return input;
+
+        // Fast path: already valid
+        try
+        {
+            JsonDocument.Parse(input);
+            return input;
+        }
+        catch (JsonException) { }
+
+        var sb = new StringBuilder(input.Length + 16);
+        int i = 0;
+        bool inDouble = false;
+        bool inSingle = false;
+        bool escaped = false;
+
+        while (i < input.Length)
+        {
+            char c = input[i];
+
+            // Handle escape sequences inside strings
+            if (escaped)
+            {
+                sb.Append(c);
+                escaped = false;
+                i++;
+                continue;
+            }
+
+            if (c == '\\' && (inDouble || inSingle))
+            {
+                sb.Append(c);
+                escaped = true;
+                i++;
+                continue;
+            }
+
+            // Track double-quoted string context
+            if (c == '"' && !inSingle)
+            {
+                inDouble = !inDouble;
+                sb.Append(c);
+                i++;
+                continue;
+            }
+
+            // Single-quote transitions: open → emit ", close → emit "
+            if (c == '\'' && !inDouble)
+            {
+                inSingle = !inSingle;
+                sb.Append('"');
+                i++;
+                continue;
+            }
+
+            // Inside a single-quoted string: escape any bare double-quotes
+            if (inSingle && c == '"')
+            {
+                sb.Append('\\');
+                sb.Append('"');
+                i++;
+                continue;
+            }
+
+            // Outside strings: quote bare object/array keys after { or ,
+            if (!inDouble && !inSingle && (c == '{' || c == ','))
+            {
+                sb.Append(c);
+                i++;
+
+                // Consume and emit whitespace
+                while (i < input.Length && char.IsWhiteSpace(input[i]))
+                {
+                    sb.Append(input[i]);
+                    i++;
+                }
+
+                // If the next char starts a bare identifier (not a quote or structural char),
+                // wrap it in double quotes.
+                if (i < input.Length)
+                {
+                    char next = input[i];
+                    if (next != '"' && next != '\'' && next != '}' && next != ']'
+                        && (char.IsLetter(next) || next == '_'))
+                    {
+                        sb.Append('"');
+                        while (i < input.Length && (char.IsLetterOrDigit(input[i]) || input[i] == '_'))
+                        {
+                            sb.Append(input[i]);
+                            i++;
+                        }
+                        sb.Append('"');
+                    }
+                }
+
+                continue;
+            }
+
+            sb.Append(c);
+            i++;
+        }
+
+        return sb.ToString();
+    }
+}

src/CalendarMcp.Tests/Utilities/TimeZoneHelperTests.cs

@@ -67,4 +67,28 @@ public void TryGetTimeZone_EmptyInput_ReturnsNull()
         var tz = TimeZoneHelper.TryGetTimeZone("");
         Assert.IsNull(tz);
     }
+
+    [TestMethod]
+    public void TryGetTimeZone_SingleQuotedId_ReturnsTimeZoneInfo()
+    {
+        // LLMs sometimes echo schema examples verbatim, producing 'America/Chicago'
+        var tz = TimeZoneHelper.TryGetTimeZone("'America/Chicago'");
+        Assert.IsNotNull(tz);
+        Assert.AreEqual("America/Chicago", tz.Id);
+    }
+
+    [TestMethod]
+    public void TryGetTimeZone_BacktickQuotedId_ReturnsTimeZoneInfo()
+    {
+        var tz = TimeZoneHelper.TryGetTimeZone("`America/Chicago`");
+        Assert.IsNotNull(tz);
+        Assert.AreEqual("America/Chicago", tz.Id);
+    }
+
+    [TestMethod]
+    public void TryGetTimeZone_MismatchedQuotes_ReturnsNull()
+    {
+        var tz = TimeZoneHelper.TryGetTimeZone("'America/Chicago`");
+        Assert.IsNull(tz);
+    }
 }

src/CalendarMcp.Tests/Utilities/ToolArgumentParserTests.cs

@@ -0,0 +1,93 @@
+using CalendarMcp.Core.Utilities;
+
+namespace CalendarMcp.Tests.Utilities;
+
+[TestClass]
+public class ToolArgumentParserTests
+{
+    // ── NormalizeSingleQuotedJson ────────────────────────────────────────────
+
+    [TestMethod]
+    public void Normalize_AlreadyValidJson_ReturnsUnchanged()
+    {
+        const string input = """{"timeZone":"America/Chicago"}""";
+        Assert.AreEqual(input, ToolArgumentParser.NormalizeSingleQuotedJson(input));
+    }
+
+    [TestMethod]
+    public void Normalize_SingleQuotedValues_ConvertsToDoubleQuotes()
+    {
+        var result = ToolArgumentParser.NormalizeSingleQuotedJson("{'timeZone':'America/Chicago'}");
+        Assert.AreEqual("""{"timeZone":"America/Chicago"}""", result);
+    }
+
+    [TestMethod]
+    public void Normalize_BareKeys_QuotesKeys()
+    {
+        var result = ToolArgumentParser.NormalizeSingleQuotedJson("{timeZone:'America/Chicago'}");
+        Assert.AreEqual("""{"timeZone":"America/Chicago"}""", result);
+    }
+
+    [TestMethod]
+    public void Normalize_MultipleFields_HandlesAll()
+    {
+        var result = ToolArgumentParser.NormalizeSingleQuotedJson(
+            "{timeZone:'America/Chicago',startDate:'2026-01-01'}");
+        Assert.AreEqual("""{"timeZone":"America/Chicago","startDate":"2026-01-01"}""", result);
+    }
+
+    [TestMethod]
+    public void Normalize_DoubleQuoteInsideSingleQuotedString_EscapesIt()
+    {
+        // Single-quoted string containing a double-quote character
+        var result = ToolArgumentParser.NormalizeSingleQuotedJson("{msg:'say \"hi\"'}");
+        Assert.AreEqual("""{"msg":"say \"hi\""}""", result);
+    }
+
+    [TestMethod]
+    public void Normalize_MixedQuotedKeys_HandlesDoubleQuotedKeys()
+    {
+        // Keys already in double quotes should not be double-wrapped
+        var result = ToolArgumentParser.NormalizeSingleQuotedJson("""{"timeZone":'America/Chicago'}""");
+        Assert.AreEqual("""{"timeZone":"America/Chicago"}""", result);
+    }
+
+    [TestMethod]
+    public void Normalize_NullOrWhitespace_ReturnsUnchanged()
+    {
+        Assert.AreEqual("", ToolArgumentParser.NormalizeSingleQuotedJson(""));
+        Assert.AreEqual("   ", ToolArgumentParser.NormalizeSingleQuotedJson("   "));
+    }
+
+    // ── ParseArguments ───────────────────────────────────────────────────────
+
+    private record TzArgs(string TimeZone, string? StartDate = null);
+
+    private static readonly System.Text.Json.JsonSerializerOptions CaseInsensitive =
+        new() { PropertyNameCaseInsensitive = true };
+
+    [TestMethod]
+    public void ParseArguments_StrictJson_Deserializes()
+    {
+        var result = ToolArgumentParser.ParseArguments<TzArgs>(
+            """{"timeZone":"America/Chicago"}""", CaseInsensitive);
+        Assert.IsNotNull(result);
+        Assert.AreEqual("America/Chicago", result.TimeZone);
+    }
+
+    [TestMethod]
+    public void ParseArguments_SingleQuotedJson_DeserializesViaFallback()
+    {
+        var result = ToolArgumentParser.ParseArguments<TzArgs>(
+            "{timeZone:'America/Chicago'}", CaseInsensitive);
+        Assert.IsNotNull(result);
+        Assert.AreEqual("America/Chicago", result.TimeZone);
+    }
+
+    [TestMethod]
+    public void ParseArguments_NullOrWhitespace_ReturnsDefault()
+    {
+        Assert.IsNull(ToolArgumentParser.ParseArguments<TzArgs>(null!));
+        Assert.IsNull(ToolArgumentParser.ParseArguments<TzArgs>(""));
+    }
+}