test_diff.txt

diff --git a/AgentCore.MEAI/MEAIExtensions.cs b/AgentCore.MEAI/MEAIExtensions.cs
index 3f177c7..938159e 100644
--- a/AgentCore.MEAI/MEAIExtensions.cs
+++ b/AgentCore.MEAI/MEAIExtensions.cs
@@ -102,10 +102,13 @@ internal static class MEAIExtensions
     {
         foreach (var tool in tools)
         {
-            yield return AIFunctionFactory.Create(
-                (string args) => args, 
-                name: tool.Name, 
-                description: tool.Description);
+            var schemaElement = JsonSerializer.Deserialize<JsonElement>(
+                tool.ParametersSchema.ToJsonString());
+
+            yield return AIFunctionFactory.CreateDeclaration(
+                name: tool.Name,
+                description: tool.Description,
+                jsonSchema: schemaElement);
         }
     }
 
diff --git a/AgentCore.MEAI/MEAILLMClient.cs b/AgentCore.MEAI/MEAILLMClient.cs
index b251c30..ca118a2 100644
--- a/AgentCore.MEAI/MEAILLMClient.cs
+++ b/AgentCore.MEAI/MEAILLMClient.cs
@@ -37,6 +37,10 @@ public sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
             meaiOptions.Tools = tools.ToMEAITools().ToList();
         }
 
+        // MEAI gives us COMPLETE FunctionCallContent objects (not streaming deltas).
+        // Each one needs a unique index so LLMExecutor treats them as separate tool calls.
+        int toolCallIndex = 0;
+
         await foreach (var update in _client.GetStreamingResponseAsync(meaiMessages, meaiOptions, ct).WithCancellation(ct))
         {
             if (update.FinishReason.HasValue)
@@ -59,13 +63,15 @@ public sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
                         break;
 
                     case FunctionCallContent fc:
+                        var argsDelta = fc.Arguments?.Count > 0 
+                            ? System.Text.Json.JsonSerializer.Serialize(fc.Arguments) 
+                            : null;
+
                         yield return new ToolCallDelta(
-                            Index: 0, 
+                            Index: toolCallIndex++,  // unique index per tool call
                             Id: fc.CallId,
                             Name: fc.Name,
-                            ArgumentsDelta: fc.Arguments?.Count > 0 
-                                ? System.Text.Json.JsonSerializer.Serialize(fc.Arguments) 
-                                : null
+                            ArgumentsDelta: argsDelta
                         );
                         break;
 
@@ -73,7 +79,7 @@ public sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
                         if (u.Details != null)
                         {
                             yield return new MetaDelta(
-                                AgentCore.LLM.FinishReason.Stop, 
+                                null, 
                                 new TokenUsage(
                                     (int)(u.Details.InputTokenCount ?? 0), 
                                     (int)(u.Details.OutputTokenCount ?? 0),
@@ -85,3 +91,4 @@ public sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
         }
     }
 }
+
diff --git a/AgentCore.OpenAI/AgentCore.OpenAI.csproj b/AgentCore.OpenAI/AgentCore.OpenAI.csproj
deleted file mode 100644
index 3d7ad7b..0000000
--- a/AgentCore.OpenAI/AgentCore.OpenAI.csproj
+++ /dev/null
@@ -1,20 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<PropertyGroup>
-		<TargetFramework>net8.0</TargetFramework>
-		<ImplicitUsings>enable</ImplicitUsings>
-		<LangVersion>latest</LangVersion>
-		<Nullable>enable</Nullable>
-		<PackageOutputPath>$(MSBuildProjectDirectory)\.nuget</PackageOutputPath>
-	</PropertyGroup>
-
-	<ItemGroup>
-		<ProjectReference Include="..\AgentCore\AgentCore.csproj" />
-	</ItemGroup>
-
-	<ItemGroup>
-		<PackageReference Include="OpenAI" Version="2.9.1" />
-		<PackageReference Include="SharpToken" Version="2.0.4" />
-	</ItemGroup>
-
-</Project>
diff --git a/AgentCore.OpenAI/OpenAIExtensions.cs b/AgentCore.OpenAI/OpenAIExtensions.cs
deleted file mode 100644
index 1b39230..0000000
--- a/AgentCore.OpenAI/OpenAIExtensions.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-using AgentCore.Conversation;
-using AgentCore.Json;
-using AgentCore.LLM;
-using AgentCore.Tooling;
-using OpenAI.Chat;
-using System.Text.Json.Nodes;
-
-namespace AgentCore.Providers.OpenAI;
-
-public static class OpenAIExtensions
-{
-    public static FinishReason ToChatFinishReason(this ChatFinishReason reason) => reason switch
-    {
-        ChatFinishReason.Stop => FinishReason.Stop,
-        ChatFinishReason.ToolCalls => FinishReason.ToolCall,
-        _ => FinishReason.Stop
-    };
-
-    public static ChatToolChoice ToChatToolChoice(this ToolCallMode mode) => mode switch
-    {
-        ToolCallMode.None => ChatToolChoice.CreateNoneChoice(),
-        ToolCallMode.Required => ChatToolChoice.CreateRequiredChoice(),
-        _ => ChatToolChoice.CreateAutoChoice()
-    };
-
-    public static List<ChatTool> ToChatTools(this IEnumerable<Tool> tools)
-        => tools.Select(tool => ChatTool.CreateFunctionTool(
-            tool.Name,
-            tool.Description ?? "",
-            BinaryData.FromString(tool.ParametersSchema?.ToJsonString() ?? "{\"type\":\"object\"}")
-        )).ToList();
-
-    public static IEnumerable<ChatMessage> ToChatMessages(this IReadOnlyList<Message> history)
-    {
-        foreach (var msg in history)
-        {
-            switch (msg.Role)
-            {
-                case Role.System:
-                    var sysText = msg.Contents.OfType<Text>().FirstOrDefault();
-                    var sysSummary = msg.Contents.OfType<Summary>().FirstOrDefault();
-                    var sysContent = sysText?.Value ?? sysSummary?.ForLlm() ?? "";
-                    if (!string.IsNullOrEmpty(sysContent))
-                        yield return ChatMessage.CreateSystemMessage(sysContent);
-                    break;
-
-                case Role.User:
-                    var userText = msg.Contents.OfType<Text>().FirstOrDefault();
-                    if (userText != null)
-                        yield return ChatMessage.CreateUserMessage(userText.Value);
-                    break;
-
-                case Role.Assistant:
-                    var assistantText = msg.Contents.OfType<Text>().FirstOrDefault();
-                    var reasoning = msg.Contents.OfType<Reasoning>().FirstOrDefault();
-                    var toolCalls = msg.Contents.OfType<ToolCall>().ToList();
-
-                    if (toolCalls.Count > 0)
-                    {
-                        yield return ChatMessage.CreateAssistantMessage(
-                            toolCalls: toolCalls.Select(call => ChatToolCall.CreateFunctionToolCall(
-                                id: call.Id,
-                                functionName: call.Name,
-                                functionArguments: BinaryData.FromString(call.Arguments?.ToJsonString() ?? "{}"))).ToList());
-                    }
-                    else if (assistantText != null || reasoning != null)
-                    {
-                        var text = assistantText?.Value ?? "";
-                        yield return ChatMessage.CreateAssistantMessage(text);
-                    }
-                    break;
-
-                case Role.Tool:
-                    var toolResult = msg.Contents.OfType<ToolResult>().FirstOrDefault();
-                    if (toolResult != null)
-                    {
-                        var payload = toolResult.Result == null ? "{}" : toolResult.Result.AsJsonString();
-                        yield return ChatMessage.CreateToolMessage(toolResult.CallId, payload);
-                    }
-                    break;
-            }
-        }
-    }
-
-    public static void ApplySamplingOptions(this ChatCompletionOptions opts, LLMOptions? options)
-    {
-        var s = options;
-        if (s == null) return;
-
-        if (s.Temperature.HasValue) opts.Temperature = s.Temperature.Value;
-        if (s.TopP.HasValue) opts.TopP = s.TopP.Value;
-        if (s.MaxOutputTokens.HasValue) opts.MaxOutputTokenCount = s.MaxOutputTokens.Value;
-#pragma warning disable OPENAI001
-        if (s.Seed.HasValue) opts.Seed = s.Seed.Value;
-#pragma warning restore OPENAI001
-        if (s.FrequencyPenalty.HasValue) opts.FrequencyPenalty = s.FrequencyPenalty.Value;
-        if (s.PresencePenalty.HasValue) opts.PresencePenalty = s.PresencePenalty.Value;
-
-        if (s.StopSequences is { Count: > 0 })
-            foreach (var stop in s.StopSequences)
-                opts.StopSequences.Add(stop);
-    }
-}
diff --git a/AgentCore.OpenAI/OpenAILLMClient.cs b/AgentCore.OpenAI/OpenAILLMClient.cs
deleted file mode 100644
index 1efb635..0000000
--- a/AgentCore.OpenAI/OpenAILLMClient.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-using AgentCore.Conversation;
-using AgentCore.LLM;
-using AgentCore.Tooling;
-
-using OpenAI;
-using OpenAI.Chat;
-using System.ClientModel;
-
-namespace AgentCore.Providers.OpenAI;
-
-internal sealed class OpenAILLMClient : ILLMProvider
-{
-    private readonly OpenAIClient _client;
-    private readonly string _defaultModel;
-
-    public OpenAILLMClient(LLMOptions options)
-    {
-        var opts = options;
-        _client = new OpenAIClient(
-            new ApiKeyCredential(opts.ApiKey!),
-            new OpenAIClientOptions { Endpoint = new Uri(opts.BaseUrl!) }
-        );
-        _defaultModel = opts.Model ?? throw new InvalidOperationException("Model must be specified in LLMOptions.");
-    }
-
-    public async IAsyncEnumerable<IContentDelta> StreamAsync(
-        IReadOnlyList<Message> messages,
-        LLMOptions options,
-        IReadOnlyList<Tool>? tools = null,
-        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken ct = default)
-    {
-        var model = options.Model ?? _defaultModel;
-        var chat = _client.GetChatClient(model);
-        var chatOptions = BuildChatOptions(options, tools);
-
-        string? pendingToolId = null;
-        string? pendingToolName = null;
-
-        await foreach (var update in chat.CompleteChatStreamingAsync(
-            messages.ToChatMessages(), chatOptions, ct).WithCancellation(ct))
-        {
-            if (update.ContentUpdate is { } content)
-            {
-                foreach (var c in content)
-                {
-                    if (c.Text is { } t)
-                        yield return new TextDelta(t);
-                }
-            }
-
-            if (update.ToolCallUpdates is { } tcuList)
-            {
-                foreach (var tcu in tcuList)
-                {
-                    pendingToolId ??= tcu.ToolCallId;
-                    pendingToolName ??= tcu.FunctionName;
-
-                    if (tcu.FunctionArgumentsUpdate is { } argToken)
-                    {
-                        yield return new ToolCallDelta(
-                            Index: tcu.Index,
-                            Id: pendingToolId,
-                            Name: pendingToolName,
-                            ArgumentsDelta: argToken.ToString()
-                        );
-                    }
-                }
-            }
-
-            if (update.Usage is { } usage)
-                yield return new MetaDelta(FinishReason.Stop, new global::AgentCore.Tokens.TokenUsage(usage.InputTokenCount, usage.OutputTokenCount));
-
-            if (update.FinishReason is { } finish)
-                yield return new MetaDelta(finish.ToChatFinishReason(), null);
-        }
-    }
-
-    private static ChatCompletionOptions BuildChatOptions(LLMOptions options, IReadOnlyList<Tool>? tools)
-    {
-        var o = new ChatCompletionOptions();
-
-        // Sampling
-        o.ApplySamplingOptions(options);
-
-        // Structured output
-        if (options.ResponseSchema != null)
-        {
-            o.ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
-                "structured_response",
-                BinaryData.FromString(options.ResponseSchema.ToJsonString()),
-                jsonSchemaIsStrict: true
-            );
-        }
-
-        // Tools
-        o.ToolChoice = options.ToolCallMode.ToChatToolChoice();
-        if (tools != null)
-            foreach (var t in tools.ToChatTools())
-                o.Tools.Add(t);
-
-        return o;
-    }
-}
diff --git a/AgentCore.OpenAI/OpenAIServiceExtensions.cs b/AgentCore.OpenAI/OpenAIServiceExtensions.cs
deleted file mode 100644
index 5535184..0000000
--- a/AgentCore.OpenAI/OpenAIServiceExtensions.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using AgentCore.LLM;
-using AgentCore.Tokens;
-
-
-namespace AgentCore.Providers.OpenAI;
-
-public static class OpenAIServiceExtensions
-{
-    public static AgentBuilder AddOpenAI(this AgentBuilder builder, Action<LLMOptions> configure)
-    {
-        var options = new LLMOptions();
-        configure(options);
-
-        var provider = new OpenAILLMClient(options);
-        builder.WithProvider(provider, options);
-
-        var encoding = options.Model?.StartsWith("gpt-4o") == true ? "o200k_base" : "cl100k_base";
-        var tokenCounter = new TikTokenCounter(encoding);
-        builder.WithTokenCounter(tokenCounter);
-
-        return builder;
-    }
-}
diff --git a/AgentCore.OpenAI/TikTokenCounter.cs b/AgentCore.OpenAI/TikTokenCounter.cs
deleted file mode 100644
index 5f41188..0000000
--- a/AgentCore.OpenAI/TikTokenCounter.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using AgentCore.Conversation;
-using AgentCore.Json;
-using AgentCore.Tokens;
-using SharpToken;
-using System.Runtime.CompilerServices;
-
-namespace AgentCore.Providers.OpenAI;
-
-public sealed class TikTokenCounter(string encodingName) : ITokenCounter
-{
-    private readonly GptEncoding _encoding = GptEncoding.GetEncoding(encodingName);
-    private static readonly ConditionalWeakTable<Message, IntBox> _cache = new();
-    private sealed class IntBox(int count) { public int Count = count; }
-
-    public Task<int> CountAsync(IEnumerable<Message> messages, CancellationToken ct = default)
-    {
-        if (messages == null || !messages.Any()) return Task.FromResult(0);
-        
-        int total = 0;
-        foreach (var m in messages)
-        {
-            if (_cache.TryGetValue(m, out var box))
-            {
-                total += box.Count;
-            }
-            else
-            {
-                int c = _encoding.Encode(new[] { m }.ToJson()).Count;
-                _cache.Add(m, new IntBox(c));
-                total += c;
-            }
-        }
-        return Task.FromResult(total);
-    }
-}
diff --git a/AgentCore.sln b/AgentCore.sln
index a60ed53..706ce16 100644
--- a/AgentCore.sln
+++ b/AgentCore.sln
@@ -1,3 +1,4 @@
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 18
 VisualStudioVersion = 18.4.11513.90
diff --git a/AgentCore/Agent.cs b/AgentCore/Agent.cs
index 3512ccc..f7ffa3c 100644
--- a/AgentCore/Agent.cs
+++ b/AgentCore/Agent.cs
@@ -123,6 +123,9 @@ public sealed class LLMAgent : IAgent
         }))
         {
             var chat = await _memory.RecallAsync(sessionId);
+            var isNewSession = chat.Count == 0;
+            _logger.LogInformation("Agent invoked: Session={SessionId} InputLength={Len} NewSession={IsNew}", sessionId, input.ForLlm().Length, isNewSession);
+            
             var userMessage = new Message(Role.User, input);
             chat.Add(userMessage);
 
@@ -146,6 +149,7 @@ public sealed class LLMAgent : IAgent
 
                 var runningTools = new List<Task<ToolResult>>();
                 var messages = (IReadOnlyList<Message>)chat.GetActiveWindow();
+                _logger.LogDebug("LLM step {Step}: Messages={Count} ContextTokensΓëê{Approx}", consecutiveToolSteps + 1, messages.Count, lastLlmTokens);
 
                 await foreach (var evt in _llm.StreamAsync(messages, options, ct))
                 {
@@ -186,7 +190,15 @@ public sealed class LLMAgent : IAgent
                             break;
 
                         case LLMMetaEvent meta:
-                            lastLlmTokens = meta.Usage.InputTokens + meta.Usage.OutputTokens;
+                            if (meta.Usage.IsEmpty)
+                            {
+                                lastLlmTokens = await _tokenCounter.CountAsync(chat.GetActiveWindow(), ct).ConfigureAwait(false) + meta.ToolSchemaTokens;
+                                _logger.LogDebug("LLM Provider did not report tokens. Counted {TokenCount} natively (including {ToolSchemaTokens} tool schemas).", lastLlmTokens, meta.ToolSchemaTokens);
+                            }
+                            else
+                            {
+                                lastLlmTokens = meta.Usage.InputTokens + meta.Usage.OutputTokens;
+                            }
                             break;
                     }
 
@@ -213,22 +225,24 @@ public sealed class LLMAgent : IAgent
                 {
                     if (options.ContextLength.HasValue)
                     {
-                        if (lastLlmTokens == 0)
-                        {
-                            lastLlmTokens = await _tokenCounter.CountAsync(chat.GetActiveWindow(), ct).ConfigureAwait(false);
-                            _logger.LogDebug("LLM Provider did not report tokens. Counted {TokenCount} natively.", lastLlmTokens);
-                        }
+                        _logger.LogDebug("Context reduction requested: {Tokens}/{Limit}", lastLlmTokens, options.ContextLength.Value);
                         chat = await _ctxManager.ReduceAsync(chat, lastLlmTokens, options, ct).ConfigureAwait(false);
                     }
+                    _logger.LogDebug("Agent completed: Steps={Steps} TotalToolCalls={Count}", consecutiveToolSteps, 0);
                     await _memory.UpdateAsync(sessionId, chat);
                     break;
                 }
 
                 consecutiveToolSteps++;
+                var toolStartTime = DateTime.UtcNow;
                 var results = await Task.WhenAll(runningTools);
+                var toolDuration = (DateTime.UtcNow - toolStartTime).TotalMilliseconds;
 
                 foreach (var result in results)
                 {
+                    var resultLength = result.ForLlm()?.Length ?? 0;
+                    var toolName = pendingCalls.TryGetValue(result.CallId, out var msg) && msg.Contents.FirstOrDefault() is ToolCall tc ? tc.Name : "unknown";
+                    _logger.LogDebug("Tool result: {ToolName} Duration={Ms}ms ResultLength={Len}", toolName, toolDuration, resultLength);
                     chat.Add(new Message(Role.Tool, result));
                     yield return new AgentToolResultEvent(result);
                 }
@@ -237,11 +251,7 @@ public sealed class LLMAgent : IAgent
 
                 if (options.ContextLength.HasValue)
                 {
-                    if (lastLlmTokens == 0)
-                    {
-                        lastLlmTokens = await _tokenCounter.CountAsync(chat.GetActiveWindow(), ct).ConfigureAwait(false);
-                        _logger.LogDebug("LLM Provider did not report tokens. Counted {TokenCount} natively.", lastLlmTokens);
-                    }
+                    _logger.LogDebug("Context reduction requested: {Tokens}/{Limit}", lastLlmTokens, options.ContextLength.Value);
                     chat = await _ctxManager.ReduceAsync(chat, lastLlmTokens, options, ct).ConfigureAwait(false);
                 }
 
diff --git a/AgentCore/AgentBuilder.cs b/AgentCore/AgentBuilder.cs
index 5675495..0fdc72c 100644
--- a/AgentCore/AgentBuilder.cs
+++ b/AgentCore/AgentBuilder.cs
@@ -13,7 +13,7 @@ public sealed class AgentConfig
 {
     public string Name { get; set; } = "agent";
     public string? SystemPrompt { get; set; }
-    public int MaxToolCalls { get; set; } = 15;
+    public int? MaxToolCalls { get; set; } = null;
     public ToolOptions ToolOptions { get; set; } = new();
 }
 
@@ -74,7 +74,8 @@ public sealed class AgentBuilder
 
         var toolExecutor = new ToolExecutor(
             registry, 
-            _config.ToolOptions, 
+            _config.ToolOptions,
+            loggerFactory.CreateLogger<ToolExecutor>(),
             _toolMiddlewares);
 
         var llmExecutor = new LLMExecutor(
diff --git a/AgentCore/Conversation/ContentDelta.cs b/AgentCore/Conversation/ContentDelta.cs
index 2beaa15..8347d01 100644
--- a/AgentCore/Conversation/ContentDelta.cs
+++ b/AgentCore/Conversation/ContentDelta.cs
@@ -16,4 +16,4 @@ public sealed record ToolCallDelta(
     string? ArgumentsDelta
 ) : IContentDelta;
 
-public sealed record MetaDelta(FinishReason FinishReason, TokenUsage? TokenUsage) : IContentDelta;
+public sealed record MetaDelta(FinishReason? FinishReason, TokenUsage? TokenUsage) : IContentDelta;
diff --git a/AgentCore/Json/JsonSchemaExtensions.cs b/AgentCore/Json/JsonSchemaExtensions.cs
index 4b7ba26..8ef199b 100644
--- a/AgentCore/Json/JsonSchemaExtensions.cs
+++ b/AgentCore/Json/JsonSchemaExtensions.cs
@@ -34,7 +34,7 @@ public static class JsonSchemaExtensions
         var result = BuildSchema(type, visited);
 
         if (visited.Count == 0)
-            _schemaCache.TryAdd(type, result);
+            _schemaCache.TryAdd(type, (JsonObject)result.DeepClone());
 
         return result;
     }
@@ -138,25 +138,25 @@ public static class JsonSchemaExtensions
         switch (type)
         {
             case "string":
-                if (kind != JsonValueKind.String) errors.Add(new SchemaValidationError(path, path, "Expected string", "type_error"));
+                if (kind != JsonValueKind.String) errors.Add(new SchemaValidationError(path, path, $"Expected string, got {kind}", "type_error"));
                 break;
             case "integer":
-                if (kind != JsonValueKind.Number) errors.Add(new SchemaValidationError(path, path, "Expected integer", "type_error"));
+                if (kind != JsonValueKind.Number) errors.Add(new SchemaValidationError(path, path, $"Expected integer, got {kind}", "type_error"));
                 break;
             case "number":
-                if (kind != JsonValueKind.Number) errors.Add(new SchemaValidationError(path, path, "Expected number", "type_error"));
+                if (kind != JsonValueKind.Number) errors.Add(new SchemaValidationError(path, path, $"Expected number, got {kind}", "type_error"));
                 break;
             case "boolean":
-                if (kind != JsonValueKind.True && kind != JsonValueKind.False) errors.Add(new SchemaValidationError(path, path, "Expected boolean", "type_error"));
+                if (kind != JsonValueKind.True && kind != JsonValueKind.False) errors.Add(new SchemaValidationError(path, path, $"Expected boolean, got {kind}", "type_error"));
                 break;
             case "array":
-                if (kind != JsonValueKind.Array) errors.Add(new SchemaValidationError(path, path, "Expected array", "type_error"));
+                if (kind != JsonValueKind.Array) errors.Add(new SchemaValidationError(path, path, $"Expected array, got {kind}", "type_error"));
                 else if (schema["items"] is JsonObject itemSchema)
                     for (int i = 0; i < node.AsArray().Count; i++)
                         errors.AddRange(itemSchema.Validate(node.AsArray()[i], $"{path}[{i}]"));
                 break;
             case "object":
-                if (kind != JsonValueKind.Object) errors.Add(new SchemaValidationError(path, path, "Expected object", "type_error"));
+                if (kind != JsonValueKind.Object) errors.Add(new SchemaValidationError(path, path, $"Expected object, got {kind}", "type_error"));
                 else if (schema["properties"] is JsonObject props)
                 {
                     var objNode = node.AsObject();
@@ -176,6 +176,19 @@ public static class JsonSchemaExtensions
                                 errors.AddRange(childSchema.Validate(objNode[key], $"{path}.{key}".Trim('.')));
                         }
                     }
+
+                    if (schema[JsonSchemaConstants.AdditionalPropertiesKey] is JsonValue ap 
+                        && ap.GetValue<bool>() == false)
+                    {
+                        var schemaKeys = props.Select(p => p.Key).ToHashSet();
+                        foreach (var key in objNode.Select(k => k.Key))
+                        {
+                            if (!schemaKeys.Contains(key))
+                                errors.Add(new SchemaValidationError(key, $"{path}.{key}".Trim('.'), 
+                                    $"Unknown property '{key}'. Expected properties: [{string.Join(", ", schemaKeys)}]", 
+                                    "unexpected_key"));
+                        }
+                    }
                 }
                 break;
         }
diff --git a/AgentCore/LLM/LLMEvent.cs b/AgentCore/LLM/LLMEvent.cs
index cfe78a3..a31752d 100644
--- a/AgentCore/LLM/LLMEvent.cs
+++ b/AgentCore/LLM/LLMEvent.cs
@@ -16,5 +16,6 @@ public sealed record LLMMetaEvent(
     FinishReason FinishReason,
     string ModelName,
     TimeSpan? Duration = null,
+    int ToolSchemaTokens = 0,
     Dictionary<string, object>? Extra = null
 ) : LLMEvent;
diff --git a/AgentCore/LLM/LLMExecutor.cs b/AgentCore/LLM/LLMExecutor.cs
index d7347d4..90aef43 100644
--- a/AgentCore/LLM/LLMExecutor.cs
+++ b/AgentCore/LLM/LLMExecutor.cs
@@ -59,8 +59,10 @@ public sealed class LLMExecutor : ILLMExecutor
         var sw = Stopwatch.StartNew();
 
         var tools = _toolRegistry.Tools;
+        var toolNames = tools?.Select(t => t.Name).ToList() ?? [];
+        var toolNamesStr = string.Join(", ", toolNames);
 
-        _logger.LogTrace("LLM request: {Model} {Options}", options.Model, options);
+        _logger.LogTrace("LLM request: Model={Model} Tools=[{ToolNames}]", options.Model, toolNamesStr);
 
         var content = _provider.StreamAsync(messages, options, tools, ct);
 
@@ -115,24 +117,45 @@ public sealed class LLMExecutor : ILLMExecutor
             if (evt != null) yield return evt;
         }
 
+        var effectiveUsage = tokenUsage ?? TokenUsage.Empty;
+        var toolSchemaTokens = EstimateToolSchemaTokens(tools);
+
         if (tokenUsage != null)
         {
             _tokenManager.Record(tokenUsage);
-            yield return new LLMMetaEvent(
-                tokenUsage,
-                finishReason ?? FinishReason.Stop,
-                options.Model,
-                sw.Elapsed);
             if (_tokenCounter is ApproximateTokenCounter approx)
             {
                 approx.Calibrate(messages, tokenUsage.InputTokens);
             }
         }
+        else
+        {
+            _logger.LogDebug("Provider did not report token usage for FinishReason={FinishReason}", finishReason);
+        }
+
+        yield return new LLMMetaEvent(
+            effectiveUsage,
+            finishReason ?? FinishReason.Stop,
+            options.Model,
+            sw.Elapsed,
+            toolSchemaTokens);
 
         sw.Stop();
         _logger.LogDebug("LLM call finished: {FinishReason} Duration={Ms}ms", finishReason, sw.ElapsedMilliseconds);
-        if (tokenUsage != null)
-            _logger.LogTrace("Token usage: In={In} Out={Out}", tokenUsage.InputTokens, tokenUsage.OutputTokens);
+        _logger.LogTrace("Token usage: In={In} Out={Out} ToolSchemas={ToolSchemas}", effectiveUsage.InputTokens, effectiveUsage.OutputTokens, toolSchemaTokens);
+    }
+
+    private static int EstimateToolSchemaTokens(IReadOnlyList<AgentCore.Tooling.Tool>? tools)
+    {
+        if (tools == null || tools.Count == 0) return 0;
+        
+        int totalChars = 0;
+        foreach (var tool in tools)
+        {
+            var json = System.Text.Json.JsonSerializer.Serialize(tool);
+            totalChars += json?.Length ?? 0;
+        }
+        return (int)(totalChars / 4.0 * 1.15);
     }
 
     private static ToolCallEvent? ParseToolCall(string id, string name, string argsStr)
diff --git a/AgentCore/Tokens/SummarizingContextManager.cs b/AgentCore/Tokens/SummarizingContextManager.cs
index 17fc4fe..3ecca44 100644
--- a/AgentCore/Tokens/SummarizingContextManager.cs
+++ b/AgentCore/Tokens/SummarizingContextManager.cs
@@ -22,6 +22,8 @@ public sealed class SummarizingContextManager(
 
         if (usage < 0.90 || _provider == null) return chat;
 
+        _logger.LogInformation("Context compaction triggered: {Used}/{Limit} ({Pct:F1}%)", totalTokens, ctxLen, usage * 100);
+
         int startIndex = 0;
         for (int i = chat.Count - 1; i >= 0; i--)
         {
@@ -54,9 +56,12 @@ public sealed class SummarizingContextManager(
             if (evt is TextDelta td) sb.Append(td.Value);
         }
 
-        var summaryMsg = new Message(Role.System, new Summary(sb.ToString().Trim()));
+        var summaryContent = sb.ToString().Trim();
+        var summaryMsg = new Message(Role.System, new Summary(summaryContent));
         int insertIndex = chat.Count - keepCount;
         chat.Insert(insertIndex, summaryMsg);
+        
+        _logger.LogTrace("Summary content produced: {Summary}", summaryContent.Length > 500 ? summaryContent[..500] + "..." : summaryContent);
 
         int after = await _counter.CountAsync(chat.GetActiveWindow(), ct).ConfigureAwait(false);
         _logger.LogDebug("Compacted [summarize]: {Before}→{After} ({Saved:P0})",
diff --git a/AgentCore/Tokens/TokenManager.cs b/AgentCore/Tokens/TokenManager.cs
index 11acb3b..aab08ac 100644
--- a/AgentCore/Tokens/TokenManager.cs
+++ b/AgentCore/Tokens/TokenManager.cs
@@ -5,6 +5,8 @@ namespace AgentCore.Tokens;
 public sealed record TokenUsage(int InputTokens = 0, int OutputTokens = 0, int ReasoningTokens = 0)
 {
     public int Total => InputTokens + OutputTokens + ReasoningTokens;
+    public static TokenUsage Empty => new(0, 0, 0);
+    public bool IsEmpty => InputTokens == 0 && OutputTokens == 0 && ReasoningTokens == 0;
 }
 
 public interface ITokenManager
diff --git a/AgentCore/Tooling/ToolExecutor.cs b/AgentCore/Tooling/ToolExecutor.cs
index 9b01f4b..ac93ffb 100644
--- a/AgentCore/Tooling/ToolExecutor.cs
+++ b/AgentCore/Tooling/ToolExecutor.cs
@@ -3,6 +3,8 @@ using AgentCore.Diagnostics;
 using AgentCore.Execution;
 using AgentCore.Json;
 using AgentCore.Utils;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
 using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -21,14 +23,17 @@ public sealed class ToolExecutor : IToolExecutor
     private readonly ToolOptions _options;
     private readonly SemaphoreSlim _semaphore;
     private readonly PipelineHandler<ToolCall, Task<ToolResult>> _pipeline;
+    private readonly ILogger<ToolExecutor> _logger;
 
     public ToolExecutor(
         IToolRegistry tools,
         ToolOptions options,
+        ILogger<ToolExecutor> logger,
         IEnumerable<PipelineMiddleware<ToolCall, Task<ToolResult>>>? middlewares = null)
     {
         _tools = tools;
         _options = options;
+        _logger = logger;
         _semaphore = new SemaphoreSlim(options.MaxConcurrency);
         
         _pipeline = Pipeline<ToolCall, Task<ToolResult>>.Build(
@@ -51,11 +56,15 @@ public sealed class ToolExecutor : IToolExecutor
         if (string.IsNullOrWhiteSpace(call.Name))
             return new ToolResult(call.Id, new ToolValidationException("Unknown", "Name", "Tool name cannot be empty."));
 
+        var argsJson = call.Arguments?.ToString() ?? "{}";
+        _logger.LogDebug("Executing tool: {Name} Args={ArgsJson}", call.Name, argsJson.Length > 500 ? argsJson[..500] + "..." : argsJson);
+
         await _semaphore.WaitAsync(ct).ConfigureAwait(false);
         
         CancellationTokenSource? timeoutCts = null;
         CancellationTokenSource? linkedCts = null;
         CancellationToken runCt = ct;
+        var sw = Stopwatch.StartNew();
 
         if (_options.DefaultTimeout.HasValue)
         {
@@ -67,16 +76,23 @@ public sealed class ToolExecutor : IToolExecutor
         try
         {
             var result = await InvokeInternalAsync(call, runCt).ConfigureAwait(false);
+            sw.Stop();
+            _logger.LogDebug("Tool completed: {Name} Duration={Ms}ms", call.Name, sw.ElapsedMilliseconds);
+            _logger.LogTrace("Tool result: {Name} Result={Content}", call.Name, result?.ForLlm()?.Length > 200 ? result.ForLlm()[..200] + "..." : result?.ForLlm());
             return new ToolResult(call.Id, result);
         }
         catch (OperationCanceledException ex) when (timeoutCts?.IsCancellationRequested == true)
         {
+            sw.Stop();
+            _logger.LogWarning("Tool failed: {Name} Error={Message}", call.Name, $"Tool execution timed out after {_options.DefaultTimeout!.Value.TotalSeconds} seconds.");
             return new ToolResult(call.Id, new ToolExecutionException(call.Name, $"Tool execution timed out after {_options.DefaultTimeout!.Value.TotalSeconds} seconds.", ex));
         }
         catch (OperationCanceledException) { throw; }
         catch (Exception ex)
         {
+            sw.Stop();
             var wrapped = ex is ToolExecutionException tex ? tex : new ToolExecutionException(call.Name, ex.Message, ex);
+            _logger.LogWarning("Tool failed: {Name} Error={Message}", call.Name, wrapped.Message);
             return new ToolResult(call.Id, wrapped);
         }
         finally
@@ -109,6 +125,19 @@ public sealed class ToolExecutor : IToolExecutor
         if (parameters.Length == 1 && !parameters[0].ParameterType.IsSimpleType() && !argsObj.ContainsKey(parameters[0].Name!))
             argsObj = new JsonObject { [parameters[0].Name!] = argsObj };
 
+        var expectedNames = parameters
+            .Where(p => p.ParameterType != typeof(CancellationToken) && p.Name != null)
+            .Select(p => p.Name!)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var unknownKeys = argsObj.Select(kv => kv.Key)
+            .Where(k => !expectedNames.Contains(k))
+            .ToList();
+        if (unknownKeys.Count > 0)
+        {
+            throw new ToolValidationException(toolName, unknownKeys[0],
+                $"Unknown parameter(s): [{string.Join(", ", unknownKeys)}]. Expected: [{FormatExpectedParams(parameters)}].");
+        }
+
         var values = new List<object?>();
 
         foreach (var p in parameters)
@@ -121,7 +150,8 @@ public sealed class ToolExecutor : IToolExecutor
             if (node == null)
             {
                 if (p.HasDefaultValue) values.Add(p.DefaultValue);
-                else throw new ToolValidationException(toolName, p.Name!, "Missing required parameter.");
+                else throw new ToolValidationException(toolName, p.Name!, 
+                    $"Missing required parameter '{p.Name}' (type: {p.ParameterType.MapClrTypeToJsonType()}). Expected parameters: [{FormatExpectedParams(parameters)}].");
                 continue;
             }
 
@@ -136,6 +166,20 @@ public sealed class ToolExecutor : IToolExecutor
         return values.ToArray();
     }
 
+    private static string FormatExpectedParams(ParameterInfo[] parameters)
+        => string.Join(", ", parameters
+            .Where(p => p.ParameterType != typeof(CancellationToken) && p.Name != null)
+            .Select(p =>
+            {
+                var type = p.ParameterType.MapClrTypeToJsonType();
+                var opt = p.HasDefaultValue ? ", optional" : "";
+                var underlying = Nullable.GetUnderlyingType(p.ParameterType) ?? p.ParameterType;
+                var enumVals = underlying.IsEnum 
+                    ? $", one of: {string.Join("|", Enum.GetNames(underlying))}" 
+                    : "";
+                return $"{p.Name} ({type}{opt}{enumVals})";
+            }));
+
     private static readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions
     {
         Converters = { new System.Text.Json.Serialization.JsonStringEnumConverter() }
@@ -173,7 +217,7 @@ public abstract class ToolException : Exception, IContent
         ToolName = toolName;
     }
     public virtual string ForLlm()
-        => $"{ToolName}: {Message}";
+        => $"Error calling tool '{ToolName}': {Message}";
 }
 public sealed class ToolExecutionException : ToolException
 {
@@ -188,7 +232,8 @@ public sealed class ToolValidationAggregateException : ToolException
     {
         Errors = errors.ToList();
     }
-    public override string ForLlm() => $"{ToolName}: {Message}";
+    public override string ForLlm() 
+        => $"Error calling tool '{ToolName}': {string.Join("; ", Errors.Select(e => e.Message))}";
 }
 public sealed class ToolValidationException : ToolException
 {
@@ -198,4 +243,6 @@ public sealed class ToolValidationException : ToolException
     {
         ParamName = paramName;
     }
+    public override string ForLlm()
+        => $"Error calling tool '{ToolName}', parameter '{ParamName}': {Message}";
 }
diff --git a/TestApp/ChatBotAgent.cs b/TestApp/ChatBotAgent.cs
index 3e91297..e62313d 100644
--- a/TestApp/ChatBotAgent.cs
+++ b/TestApp/ChatBotAgent.cs
@@ -38,7 +38,7 @@ namespace TestApp
                 .WithProvider(MEAILLMClient.Create("http://127.0.0.1:1234/v1", "model", "lmstudio"), new LLMOptions
                 {
                     ContextLength = 8000,
-                    ReasoningEffort = AgentCore.LLM.ReasoningEffort.High
+                    ReasoningEffort = AgentCore.LLM.ReasoningEffort.Low,
                 })
                 .WithTools<GeoTools>()
                 .WithTools<WeatherTool>()
commit 655b445a1860f1c8120cc2b16dda22af94dc7850
Author: MrRazor22 <senthilvenkat22@gmail.com>
Date:   Sun Mar 29 22:34:15 2026 +0530

    reasoning works now!

diff --git a/AgentCore.MEAI/AgentCore.MEAI.csproj b/AgentCore.MEAI/AgentCore.MEAI.csproj
index 9a5fe8c..e43de43 100644
--- a/AgentCore.MEAI/AgentCore.MEAI.csproj
+++ b/AgentCore.MEAI/AgentCore.MEAI.csproj
@@ -7,8 +7,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.AI.Abstractions" Version="10.3.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.1" />
+    <PackageReference Include="Microsoft.Extensions.AI.Abstractions" Version="10.4.1" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" Version="10.4.1" />
+    <PackageReference Include="OpenAI" Version="2.9.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/AgentCore.MEAI/MEAIExtensions.cs b/AgentCore.MEAI/MEAIExtensions.cs
index daada5b..3f177c7 100644
--- a/AgentCore.MEAI/MEAIExtensions.cs
+++ b/AgentCore.MEAI/MEAIExtensions.cs
@@ -18,17 +18,24 @@ internal static class MEAIExtensions
                 Role = msg.Role.ToMEAIChatRole()
             };
             
-            if (msg.Content is Text t)
+            foreach (var content in msg.Contents)
             {
-                chatMsg.Contents.Add(new TextContent(t.Value));
-            }
-            else if (msg.Content is ToolCall tc)
-            {
-                chatMsg.Contents.Add(new FunctionCallContent(tc.Id, tc.Name, tc.Arguments.ToDictionary()));
-            }
-            else if (msg.Content is ToolResult tr)
-            {
-                chatMsg.Contents.Add(new FunctionResultContent(tr.CallId, tr.Result?.AsJsonString() ?? "{}"));
+                if (content is Text t)
+                {
+                    chatMsg.Contents.Add(new TextContent(t.Value));
+                }
+                else if (content is Reasoning r)
+                {
+                    chatMsg.Contents.Add(new Microsoft.Extensions.AI.TextReasoningContent(r.Thought));
+                }
+                else if (content is ToolCall tc)
+                {
+                    chatMsg.Contents.Add(new FunctionCallContent(tc.Id, tc.Name, tc.Arguments.ToDictionary()));
+                }
+                else if (content is ToolResult tr)
+                {
+                    chatMsg.Contents.Add(new FunctionResultContent(tr.CallId, tr.Result?.AsJsonString() ?? "{}"));
+                }
             }
             
             yield return chatMsg;
diff --git a/AgentCore.MEAI/MEAILLMClient.cs b/AgentCore.MEAI/MEAILLMClient.cs
index 4e9ed73..b251c30 100644
--- a/AgentCore.MEAI/MEAILLMClient.cs
+++ b/AgentCore.MEAI/MEAILLMClient.cs
@@ -3,12 +3,26 @@ using AgentCore.LLM;
 using AgentCore.Tokens;
 using AgentCore.Tooling;
 using Microsoft.Extensions.AI;
+using OpenAI;
+using OpenAI.Chat;
+using System.ClientModel;
 using System.Runtime.CompilerServices;
 
 namespace AgentCore.Providers.MEAI;
 
-internal sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
+public sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
 {
+    public static MEAILLMClient Create(string baseUrl, string model, string? apiKey = null)
+    {
+        var credentials = new ApiKeyCredential(apiKey ?? "not-needed");
+        var options = new OpenAIClientOptions { Endpoint = new Uri(baseUrl) };
+        var openAiClient = new OpenAIClient(credentials, options);
+        
+        var chatClient = openAiClient.GetChatClient(model);
+        var meaiClient = chatClient.AsIChatClient();
+        return new MEAILLMClient(meaiClient);
+    }
+
     public async IAsyncEnumerable<IContentDelta> StreamAsync(
         IReadOnlyList<Message> messages,
         LLMOptions options,
@@ -39,8 +53,12 @@ internal sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
                             yield return new TextDelta(t.Text);
                         break;
 
+                    case Microsoft.Extensions.AI.TextReasoningContent tr:
+                        if (!string.IsNullOrEmpty(tr.Text))
+                            yield return new ReasoningDelta(tr.Text);
+                        break;
+
                     case FunctionCallContent fc:
-                        // MEAI delivers function call updates. 
                         yield return new ToolCallDelta(
                             Index: 0, 
                             Id: fc.CallId,
@@ -52,12 +70,15 @@ internal sealed class MEAILLMClient(IChatClient _client) : ILLMProvider
                         break;
 
                     case UsageContent u:
-                        yield return new MetaDelta(
-                            AgentCore.LLM.FinishReason.Stop, 
-                            new TokenUsage(
-                                (int)u.Details.InputTokenCount, 
-                                (int)u.Details.OutputTokenCount,
-                                (int)u.Details.ReasoningTokenCount));
+                        if (u.Details != null)
+                        {
+                            yield return new MetaDelta(
+                                AgentCore.LLM.FinishReason.Stop, 
+                                new TokenUsage(
+                                    (int)(u.Details.InputTokenCount ?? 0), 
+                                    (int)(u.Details.OutputTokenCount ?? 0),
+                                    (int)(u.Details.ReasoningTokenCount ?? 0)));
+                        }
                         break;
                 }
             }
diff --git a/AgentCore.OpenAI/AgentCore.OpenAI.csproj b/AgentCore.OpenAI/AgentCore.OpenAI.csproj
index 048af9e..3d7ad7b 100644
--- a/AgentCore.OpenAI/AgentCore.OpenAI.csproj
+++ b/AgentCore.OpenAI/AgentCore.OpenAI.csproj
@@ -13,7 +13,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="OpenAI" Version="2.8.0" />
+		<PackageReference Include="OpenAI" Version="2.9.1" />
 		<PackageReference Include="SharpToken" Version="2.0.4" />
 	</ItemGroup>
 
diff --git a/AgentCore.OpenAI/OpenAIExtensions.cs b/AgentCore.OpenAI/OpenAIExtensions.cs
index aeccdf6..1b39230 100644
--- a/AgentCore.OpenAI/OpenAIExtensions.cs
+++ b/AgentCore.OpenAI/OpenAIExtensions.cs
@@ -36,37 +36,48 @@ public static class OpenAIExtensions
         {
             switch (msg.Role)
             {
-                case Role.System when msg.Content is Text sysText:
-                    yield return ChatMessage.CreateSystemMessage(sysText.Value);
+                case Role.System:
+                    var sysText = msg.Contents.OfType<Text>().FirstOrDefault();
+                    var sysSummary = msg.Contents.OfType<Summary>().FirstOrDefault();
+                    var sysContent = sysText?.Value ?? sysSummary?.ForLlm() ?? "";
+                    if (!string.IsNullOrEmpty(sysContent))
+                        yield return ChatMessage.CreateSystemMessage(sysContent);
                     break;
 
-                case Role.System when msg.Content is Summary summary:
-                    yield return ChatMessage.CreateSystemMessage(summary.ForLlm());
+                case Role.User:
+                    var userText = msg.Contents.OfType<Text>().FirstOrDefault();
+                    if (userText != null)
+                        yield return ChatMessage.CreateUserMessage(userText.Value);
                     break;
 
-                case Role.User when msg.Content is Text userText:
-                    yield return ChatMessage.CreateUserMessage(userText.Value);
-                    break;
-
-                case Role.Assistant when msg.Content is Text assistantText:
-                    yield return ChatMessage.CreateAssistantMessage(assistantText.Value);
-                    break;
+                case Role.Assistant:
+                    var assistantText = msg.Contents.OfType<Text>().FirstOrDefault();
+                    var reasoning = msg.Contents.OfType<Reasoning>().FirstOrDefault();
+                    var toolCalls = msg.Contents.OfType<ToolCall>().ToList();
 
-                case Role.Assistant when msg.Content is ToolCall call:
-                    yield return ChatMessage.CreateAssistantMessage(
-                        toolCalls: [ChatToolCall.CreateFunctionToolCall(
-                            id: call.Id,
-                            functionName: call.Name,
-                            functionArguments: BinaryData.FromString(call.Arguments?.ToJsonString() ?? "{}"))]);
+                    if (toolCalls.Count > 0)
+                    {
+                        yield return ChatMessage.CreateAssistantMessage(
+                            toolCalls: toolCalls.Select(call => ChatToolCall.CreateFunctionToolCall(
+                                id: call.Id,
+                                functionName: call.Name,
+                                functionArguments: BinaryData.FromString(call.Arguments?.ToJsonString() ?? "{}"))).ToList());
+                    }
+                    else if (assistantText != null || reasoning != null)
+                    {
+                        var text = assistantText?.Value ?? "";
+                        yield return ChatMessage.CreateAssistantMessage(text);
+                    }
                     break;
 
-                case Role.Tool when msg.Content is ToolResult result:
-                    var payload = result.Result == null ? "{}" : result.Result.AsJsonString();
-                    yield return ChatMessage.CreateToolMessage(result.CallId, payload);
+                case Role.Tool:
+                    var toolResult = msg.Contents.OfType<ToolResult>().FirstOrDefault();
+                    if (toolResult != null)
+                    {
+                        var payload = toolResult.Result == null ? "{}" : toolResult.Result.AsJsonString();
+                        yield return ChatMessage.CreateToolMessage(toolResult.CallId, payload);
+                    }
                     break;
-
-                default:
-                    throw new InvalidOperationException($"Invalid message state for role {msg.Role} with content {msg.Content?.GetType().Name}");
             }
         }
     }
diff --git a/AgentCore.OpenAI/OpenAILLMClient.cs b/AgentCore.OpenAI/OpenAILLMClient.cs
index 5e68824..1efb635 100644
--- a/AgentCore.OpenAI/OpenAILLMClient.cs
+++ b/AgentCore.OpenAI/OpenAILLMClient.cs
@@ -42,8 +42,10 @@ internal sealed class OpenAILLMClient : ILLMProvider
             if (update.ContentUpdate is { } content)
             {
                 foreach (var c in content)
+                {
                     if (c.Text is { } t)
                         yield return new TextDelta(t);
+                }
             }
 
             if (update.ToolCallUpdates is { } tcuList)
diff --git a/AgentCore.sln b/AgentCore.sln
index 865ed3b..a60ed53 100644
--- a/AgentCore.sln
+++ b/AgentCore.sln
@@ -1,12 +1,9 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 18
 VisualStudioVersion = 18.4.11513.90
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgentCore", "AgentCore\AgentCore.csproj", "{5A011AC0-7AB0-4559-A7D2-44CD2356BAEA}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgentCore.OpenAI", "AgentCore.OpenAI\AgentCore.OpenAI.csproj", "{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgentCore.MEAI", "AgentCore.MEAI\AgentCore.MEAI.csproj", "{C3D4E5F6-7890-1234-BCDE-A12345678901}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8EC462FD-D22E-90A8-E5CE-7E832BA40C5D}"
@@ -26,10 +23,6 @@ Global
 		{5A011AC0-7AB0-4559-A7D2-44CD2356BAEA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5A011AC0-7AB0-4559-A7D2-44CD2356BAEA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5A011AC0-7AB0-4559-A7D2-44CD2356BAEA}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.Build.0 = Release|Any CPU
 		{C3D4E5F6-7890-1234-BCDE-A12345678901}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{C3D4E5F6-7890-1234-BCDE-A12345678901}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C3D4E5F6-7890-1234-BCDE-A12345678901}.Release|Any CPU.ActiveCfg = Release|Any CPU
diff --git a/AgentCore/Agent.cs b/AgentCore/Agent.cs
index ed22c84..3512ccc 100644
--- a/AgentCore/Agent.cs
+++ b/AgentCore/Agent.cs
@@ -162,10 +162,20 @@ public sealed class LLMAgent : IAgent
                             break;
 
                         case ToolCallEvent tc:
-                            if (textBuffer.Length > 0)
+                            if (textBuffer.Length > 0 || reasoningBuffer.Length > 0)
                             {
-                                chat.Add(new Message(Role.Assistant, new Text(textBuffer.ToString())));
-                                textBuffer.Clear();
+                                var contents = new List<IContent>();
+                                if (reasoningBuffer.Length > 0)
+                                {
+                                    contents.Add(new Reasoning(reasoningBuffer.ToString()));
+                                    reasoningBuffer.Clear();
+                                }
+                                if (textBuffer.Length > 0)
+                                {
+                                    contents.Add(new Text(textBuffer.ToString()));
+                                    textBuffer.Clear();
+                                }
+                                chat.Add(new Message(Role.Assistant, contents));
                             }
                             reasoningBuffer.Clear();
                             var callMsg = new Message(Role.Assistant, tc.Call);
@@ -183,10 +193,20 @@ public sealed class LLMAgent : IAgent
                     yield return evt; // LLMEvent IS an AgentEvent ΓÇö pass straight through
                 }
 
-                if (textBuffer.Length > 0)
+                if (textBuffer.Length > 0 || reasoningBuffer.Length > 0)
                 {
-                    chat.Add(new Message(Role.Assistant, new Text(textBuffer.ToString().Trim())));
-                    textBuffer.Clear();
+                    var contents = new List<IContent>();
+                    if (reasoningBuffer.Length > 0)
+                    {
+                        contents.Add(new Reasoning(reasoningBuffer.ToString()));
+                        reasoningBuffer.Clear();
+                    }
+                    if (textBuffer.Length > 0)
+                    {
+                        contents.Add(new Text(textBuffer.ToString().Trim()));
+                        textBuffer.Clear();
+                    }
+                    chat.Add(new Message(Role.Assistant, contents));
                 }
 
                 if (runningTools.Count == 0)
diff --git a/AgentCore/Conversation/Content.cs b/AgentCore/Conversation/Content.cs
index 8e4563b..f578e13 100644
--- a/AgentCore/Conversation/Content.cs
+++ b/AgentCore/Conversation/Content.cs
@@ -48,3 +48,8 @@ public sealed record Summary(string Text) : IContent
 {
     public string ForLlm() => Text;
 }
+
+public sealed record Reasoning(string Thought) : IContent
+{
+    public string ForLlm() => Thought;
+}
diff --git a/AgentCore/Conversation/Extensions.cs b/AgentCore/Conversation/Extensions.cs
index 265603d..5da27bd 100644
--- a/AgentCore/Conversation/Extensions.cs
+++ b/AgentCore/Conversation/Extensions.cs
@@ -62,7 +62,7 @@ internal static class Extensions
         int startIndex = 0;
         for (int i = messages.Count - 1; i >= 0; i--)
         {
-            if (messages[i].Content is Summary)
+            if (messages[i].Contents.Any(c => c is Summary))
             {
                 startIndex = i;
                 break;
@@ -82,7 +82,7 @@ internal static class Extensions
         foreach (var message in source)
         {
             if (!ShouldInclude(message, filter)) continue;
-            copy.Add(new Message(message.Role, message.Content));
+            copy.Add(new Message(message.Role, message.Contents));
         }
         return copy;
     }
@@ -151,12 +151,11 @@ internal static class Extensions
         Role.System => (filter & MessageKinds.System) != 0,
         Role.User => (filter & MessageKinds.User) != 0,
         Role.Tool => (filter & MessageKinds.ToolResults) != 0,
-        Role.Assistant => chat.Content switch
-        {
-            ToolCall => (filter & MessageKinds.ToolCalls) != 0,
-            Text => (filter & MessageKinds.Assistant) != 0,
-            _ => false
-        },
+        Role.Assistant => chat.Contents.Any(c => c is ToolCall) 
+            ? (filter & MessageKinds.ToolCalls) != 0 
+            : chat.Contents.Any(c => c is Text) 
+                ? (filter & MessageKinds.Assistant) != 0 
+                : false,
         _ => false
     };
 
@@ -170,30 +169,32 @@ internal static class Extensions
 
             var msg = new Dictionary<string, object> { ["role"] = c.Role.ToString().ToLowerInvariant() };
 
-            if (c.Content is Text text)
+            var textContent = c.Contents.OfType<Text>().FirstOrDefault();
+            if (textContent != null)
             {
-                msg["content"] = text.Value;
+                msg["content"] = textContent.Value;
             }
-            else if (c.Content is ToolCall call && (filter & MessageKinds.ToolCalls) != 0)
+
+            var toolCalls = c.Contents.OfType<ToolCall>().ToList();
+            if (toolCalls.Count > 0 && (filter & MessageKinds.ToolCalls) != 0)
             {
-                msg["tool_calls"] = new List<object>
+                msg["tool_calls"] = toolCalls.Select(call => new Dictionary<string, object>
                 {
-                    new Dictionary<string, object>
+                    ["id"] = call.Id,
+                    ["type"] = "function",
+                    ["function"] = new Dictionary<string, object>
                     {
-                        ["id"] = call.Id,
-                        ["type"] = "function",
-                        ["function"] = new Dictionary<string, object>
-                        {
-                            ["name"] = call.Name,
-                            ["arguments"] = call.Arguments ?? new JsonObject()
-                        }
+                        ["name"] = call.Name,
+                        ["arguments"] = call.Arguments ?? new JsonObject()
                     }
-                };
+                }).ToList();
             }
-            else if (c.Content is ToolResult result && (filter & MessageKinds.ToolResults) != 0)
+
+            var toolResult = c.Contents.OfType<ToolResult>().FirstOrDefault();
+            if (toolResult != null && (filter & MessageKinds.ToolResults) != 0)
             {
-                msg["tool_call_id"] = result.CallId;
-                msg["content"] = result.Result?.ForLlm() ?? "";
+                msg["tool_call_id"] = toolResult.CallId;
+                msg["content"] = toolResult.Result?.ForLlm() ?? "";
             }
 
             items.Add(msg);
diff --git a/AgentCore/Conversation/Message.cs b/AgentCore/Conversation/Message.cs
index 8fee8e9..7cc4ad5 100644
--- a/AgentCore/Conversation/Message.cs
+++ b/AgentCore/Conversation/Message.cs
@@ -3,7 +3,9 @@ namespace AgentCore.Conversation;
 public class Message
 {
     public Role Role { get; }
-    public IContent Content { get; }
+    public IReadOnlyList<IContent> Contents { get; }
 
-    public Message(Role role, IContent content) { Role = role; Content = content; }
+    public Message(Role role, IContent content) => (Role, Contents) = (role, [content]);
+
+    public Message(Role role, IReadOnlyList<IContent> contents) => (Role, Contents) = (role, contents);
 }
diff --git a/AgentCore/LLM/LLMOptions.cs b/AgentCore/LLM/LLMOptions.cs
index dbdfe5a..e77ea6a 100644
--- a/AgentCore/LLM/LLMOptions.cs
+++ b/AgentCore/LLM/LLMOptions.cs
@@ -3,6 +3,8 @@ using AgentCore.Tooling;
 
 namespace AgentCore.LLM;
 
+public enum ReasoningEffort { None, Low, Medium, High }
+
 public sealed class LLMOptions
 {
     public string? Model { get; set; }
@@ -18,4 +20,5 @@ public sealed class LLMOptions
     public float? FrequencyPenalty { get; set; }
     public float? PresencePenalty { get; set; }
     public JsonObject? ResponseSchema { get; set; }
+    public ReasoningEffort? ReasoningEffort { get; set; }
 }
diff --git a/AgentCore/Runtime/AgentMemory.cs b/AgentCore/Runtime/AgentMemory.cs
index 62b810d..f747bb3 100644
--- a/AgentCore/Runtime/AgentMemory.cs
+++ b/AgentCore/Runtime/AgentMemory.cs
@@ -127,7 +127,7 @@ public sealed class FileMemory(IOptions<FileMemoryOptions>? options) : IAgentMem
         var messages = chat.Select(m => new MessageDto
         {
             Role = m.Role.ToString(),
-            Content = SerializeContent(m.Content)
+            Content = m.Contents.Select(SerializeContent).ToList()
         }).ToList();
 
         return JsonSerializer.Serialize(messages, new JsonSerializerOptions { WriteIndented = true });
@@ -145,7 +145,8 @@ public sealed class FileMemory(IOptions<FileMemoryOptions>? options) : IAgentMem
             {
                 if (dto.Role != null)
                 {
-                    chat.Add(new Message(Enum.Parse<Role>(dto.Role), DeserializeContent(dto.Content)));
+                    var contents = DeserializeContents(dto.Content);
+                    chat.Add(new Message(Enum.Parse<Role>(dto.Role), contents));
                 }
             }
         }
@@ -153,11 +154,36 @@ public sealed class FileMemory(IOptions<FileMemoryOptions>? options) : IAgentMem
         return chat;
     }
 
+    private static List<IContent> DeserializeContents(object? obj)
+    {
+        var contents = new List<IContent>();
+        
+        if (obj is System.Text.Json.JsonElement element)
+        {
+            if (element.ValueKind == JsonValueKind.Array)
+            {
+                foreach (var item in element.EnumerateArray())
+                {
+                    var content = DeserializeContent(item);
+                    if (content != null) contents.Add(content);
+                }
+            }
+            else
+            {
+                var content = DeserializeContent(element);
+                if (content != null) contents.Add(content);
+            }
+        }
+        
+        return contents;
+    }
+
     private static object SerializeContent(IContent content)
     {
         return content switch
         {
             Text t => new { type = "text", value = t.Value },
+            Reasoning r => new { type = "reasoning", thought = r.Thought },
             ToolCall tc => new { type = "toolCall", id = tc.Id, name = tc.Name, arguments = tc.Arguments },
             ToolResult tr => new { type = "toolResult", callId = tr.CallId, result = SerializeContent(tr.Result!) },
             Summary s => new { type = "summary", text = s.Text },
@@ -214,4 +240,47 @@ public sealed class FileMemory(IOptions<FileMemoryOptions>? options) : IAgentMem
         public string? Role { get; set; }
         public object? Content { get; set; }
     }
+
+    private static IContent? DeserializeContent(JsonElement element)
+    {
+        if (element.TryGetProperty("type", out var typeProp))
+        {
+            var type = typeProp.GetString();
+            switch (type)
+            {
+                case "text":
+                    if (element.TryGetProperty("value", out var text))
+                        return new Text(text.GetString() ?? "");
+                    break;
+                case "reasoning":
+                    if (element.TryGetProperty("thought", out var thought))
+                        return new Reasoning(thought.GetString() ?? "");
+                    break;
+                case "toolCall":
+                    var id = element.TryGetProperty("id", out var idProp) ? idProp.GetString() ?? "" : "";
+                    var name = element.TryGetProperty("name", out var nameProp) ? nameProp.GetString() ?? "" : "";
+                    JsonObject args = new();
+                    if (element.TryGetProperty("arguments", out var argsProp))
+                    {
+                        try { args = JsonNode.Parse(argsProp.GetRawText())?.AsObject() ?? new JsonObject(); } catch { }
+                    }
+                    return new ToolCall(id, name, args);
+                case "toolResult":
+                    var callId = element.TryGetProperty("callId", out var callIdProp) ? callIdProp.GetString() ?? "" : "";
+                    IContent? result = null;
+                    if (element.TryGetProperty("result", out var resultProp))
+                        result = DeserializeContent(resultProp);
+                    return new ToolResult(callId, result);
+                case "summary":
+                    if (element.TryGetProperty("text", out var summaryText))
+                        return new Summary(summaryText.GetString() ?? "");
+                    break;
+            }
+        }
+
+        if (element.ValueKind == JsonValueKind.String)
+            return new Text(element.GetString() ?? "");
+
+        return new Text("");
+    }
 }
diff --git a/AgentCore/Tokens/ApproximateTokenCounter.cs b/AgentCore/Tokens/ApproximateTokenCounter.cs
index c7f1822..8b83f91 100644
--- a/AgentCore/Tokens/ApproximateTokenCounter.cs
+++ b/AgentCore/Tokens/ApproximateTokenCounter.cs
@@ -61,9 +61,13 @@ public sealed class ApproximateTokenCounter : ITokenCounter
             else
             {
                 int c = 4; // overhead
-                if (m.Content is Text t) c += t.Value?.Length ?? 0;
-                else if (m.Content is ToolCall tc) c += tc.Name.Length + (tc.Arguments?.ToString()?.Length ?? 0);
-                else if (m.Content is ToolResult tr) c += tr.Result?.ForLlm()?.Length ?? 0;
+                foreach (var content in m.Contents)
+                {
+                    if (content is Text t) c += t.Value?.Length ?? 0;
+                    else if (content is Reasoning) c += 0; // reasoning doesn't count toward token estimates
+                    else if (content is ToolCall tc) c += tc.Name.Length + (tc.Arguments?.ToString()?.Length ?? 0);
+                    else if (content is ToolResult tr) c += tr.Result?.ForLlm()?.Length ?? 0;
+                }
                 
                 _cache.Add(m, new CharCountBox(c));
                 total += c;
diff --git a/AgentCore/Tokens/SummarizingContextManager.cs b/AgentCore/Tokens/SummarizingContextManager.cs
index f6c4db0..17fc4fe 100644
--- a/AgentCore/Tokens/SummarizingContextManager.cs
+++ b/AgentCore/Tokens/SummarizingContextManager.cs
@@ -25,7 +25,7 @@ public sealed class SummarizingContextManager(
         int startIndex = 0;
         for (int i = chat.Count - 1; i >= 0; i--)
         {
-            if (chat[i].Content is Summary)
+            if (chat[i].Contents.Any(c => c is Summary))
             {
                 startIndex = i;
                 break;
@@ -39,7 +39,7 @@ public sealed class SummarizingContextManager(
         int compressibleCount = activeCount - keepCount;
 
         var compressible = chat.Skip(startIndex).Take(compressibleCount).ToList();
-        var content = compressible.Select(m => $"[{m.Role}]: {m.Content?.ForLlm() ?? ""}");
+        var content = compressible.Select(m => $"[{m.Role}]: {string.Join(", ", m.Contents.Select(c => c.ForLlm()))}");
 
         var input = new List<Message> { 
             new(Role.System, new Text(_summaryPrompt)),
diff --git a/TestApp/ChatBotAgent.cs b/TestApp/ChatBotAgent.cs
index ffffaec..3e91297 100644
--- a/TestApp/ChatBotAgent.cs
+++ b/TestApp/ChatBotAgent.cs
@@ -3,7 +3,7 @@ using AgentCore.BuiltInTools;
 using AgentCore.Json;
 using AgentCore.LLM;
 using AgentCore.LLM.BuiltInTools;
-using AgentCore.Providers.OpenAI;
+using AgentCore.Providers.MEAI;
 using AgentCore.Runtime;
 using AgentCore.Tokens;
 using Microsoft.Extensions.Logging;
@@ -35,12 +35,10 @@ namespace TestApp
 
             var agent = LLMAgent.Create("chatbot")
                 .WithInstructions("You are an AI agent, execute all user requests faithfully.")
-                .AddOpenAI(o =>
+                .WithProvider(MEAILLMClient.Create("http://127.0.0.1:1234/v1", "model", "lmstudio"), new LLMOptions
                 {
-                    o.BaseUrl = "http://127.0.0.1:1234/v1";
-                    o.ApiKey = "lmstudio";
-                    o.Model = "model";
-                    o.ContextLength = 8000;
+                    ContextLength = 8000,
+                    ReasoningEffort = AgentCore.LLM.ReasoningEffort.High
                 })
                 .WithTools<GeoTools>()
                 .WithTools<WeatherTool>()
@@ -113,11 +111,37 @@ namespace TestApp
                 try
                 {
                     var sb = new StringBuilder();
+                    var reasoningSb = new StringBuilder();
+                    var reasoningShown = false;
 
                     await foreach (var evt in agent.InvokeStreamingAsync((AgentCore.Conversation.Text)goal, sessionId, cts.Token))
                     {
-                        if (evt is TextEvent textEvt)
+                        if (evt is ReasoningEvent reasoningEvt)
                         {
+                            reasoningSb.Append(reasoningEvt.Delta);
+                            
+                            if (!reasoningShown && reasoningSb.Length > 50)
+                            {
+                                var originalColor = Console.ForegroundColor;
+                                Console.ForegroundColor = ConsoleColor.Magenta;
+                                Console.Write($"\n[Reasoning] ");
+                                Console.ForegroundColor = originalColor;
+                                reasoningShown = true;
+                            }
+                            
+                            if (reasoningShown)
+                            {
+                                Console.Write(reasoningEvt.Delta);
+                            }
+                        }
+                        else if (evt is TextEvent textEvt)
+                        {
+                            if (reasoningShown && reasoningSb.Length > 0)
+                            {
+                                Console.WriteLine();
+                                reasoningSb.Clear();
+                            }
+                            reasoningShown = false;
                             Console.Write(textEvt.Delta);
                             sb.Append(textEvt.Delta);
                         }
diff --git a/TestApp/TestApp.csproj b/TestApp/TestApp.csproj
index 4a338d6..e740493 100644
--- a/TestApp/TestApp.csproj
+++ b/TestApp/TestApp.csproj
@@ -16,7 +16,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\AgentCore\AgentCore.csproj" />
-    <ProjectReference Include="..\AgentCore.OpenAI\AgentCore.OpenAI.csproj" />
+    <ProjectReference Include="..\AgentCore.MEAI\AgentCore.MEAI.csproj" />
   </ItemGroup>
 
 </Project>