Update actions/setup-dotnet action to v6

MeetingAssistant.Tests/LiteLlmResponsesChatClientTests.cs

@@ -1,82 +1,223 @@
 using MeetingAssistant.Summary;
 using Microsoft.Extensions.AI;
 using System.Net;
+using System.Text;
+using System.Text.Json;
 
 namespace MeetingAssistant.Tests;
 
 public sealed class LiteLlmResponsesChatClientTests
 {
     [Fact]
-    public void ParserIgnoresReasoningItemsWithNullStatusAndReadsText()
+    public async Task ClientAssemblesStreamedTextResponseWithMetadataAndUsage()
     {
-        const string json = """
+        var handler = new SequencedHttpMessageHandler(
+            new HttpResponseMessage(HttpStatusCode.OK)
             {
-              "id": "resp_test",
+                Content = new StringContent(
+                    """
+                    data: {"type":"response.created","response":{"id":"resp_stream","created_at":1779147100,"model":"gpt-5.5","object":"response","output":[],"parallel_tool_calls":true,"status":"in_progress","store":false},"sequence_number":0}
+
+                    data: {"type":"response.output_item.added","output_index":0,"item":{"id":"msg_stream","type":"message","status":"in_progress","content":[],"role":"assistant"},"sequence_number":1}
+
+                    data: {"type":"response.content_part.added","item_id":"msg_stream","output_index":0,"content_index":0,"part":{"type":"output_text","annotations":[],"text":""},"sequence_number":2}
+
+                    data: {"type":"response.output_text.delta","item_id":"msg_stream","output_index":0,"content_index":0,"delta":"Streamed OK","sequence_number":3}
+
+                    data: {"type":"response.output_text.done","item_id":"msg_stream","output_index":0,"content_index":0,"text":"Streamed OK","sequence_number":4}
+
+                    data: {"type":"response.content_part.done","item_id":"msg_stream","output_index":0,"content_index":0,"part":{"type":"output_text","annotations":[],"text":"Streamed OK"},"sequence_number":5}
+
+                    data: {"type":"response.output_item.done","output_index":0,"item":{"id":"msg_stream","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"text":"Streamed OK"}],"role":"assistant"},"sequence_number":6}
+
+                    data: {"type":"response.completed","response":{"id":"resp_stream","created_at":1779147100,"model":"gpt-5.5","object":"response","output":[],"parallel_tool_calls":true,"status":"completed","store":false,"usage":{"input_tokens":12,"output_tokens":3,"total_tokens":15}},"sequence_number":7}
+
+                    data: [DONE]
+
+                    """,
+                    Encoding.UTF8,
+                    "text/event-stream")
+            });
+        using var client = CreateClient(handler, reconnectionAttempts: 0);
+
+        var response = await client.GetResponseAsync([new ChatMessage(ChatRole.User, "reply")]);
+
+        Assert.Equal("Streamed OK", response.Text);
+        Assert.Equal("resp_stream", response.ResponseId);
+        Assert.Equal("gpt-5.5", response.ModelId);
+        Assert.Equal(DateTimeOffset.FromUnixTimeSeconds(1779147100), response.CreatedAt);
+        Assert.NotNull(response.Usage);
+        Assert.Equal(12, response.Usage.InputTokenCount);
+        Assert.Equal(3, response.Usage.OutputTokenCount);
+        Assert.Equal(15, response.Usage.TotalTokenCount);
+    }
+
+    [Fact]
+    public async Task ClientAssemblesStreamedFunctionCall()
+    {
+        var handler = new SequencedHttpMessageHandler(
+            new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(
+                    """
+                    data: {"type":"response.output_item.done","output_index":0,"item":{"type":"function_call","call_id":"call_stream","name":"write_summary","arguments":"{\"markdown\":\"# Summary\\nDone\"}","status":"completed"}}
+
+                    data: {"type":"response.completed","response":{"id":"resp_stream","model":"gpt-5.5","output":[]}}
+
+                    data: [DONE]
+
+                    """,
+                    Encoding.UTF8,
+                    "text/event-stream")
+            });
+        using var client = CreateClient(handler, reconnectionAttempts: 0);
+
+        var response = await client.GetResponseAsync([new ChatMessage(ChatRole.User, "write summary")]);
+        var call = Assert.IsType<FunctionCallContent>(Assert.Single(response.Messages[0].Contents));
+
+        Assert.Equal("call_stream", call.CallId);
+        Assert.Equal("write_summary", call.Name);
+        Assert.NotNull(call.Arguments);
+        Assert.Equal("# Summary\nDone", call.Arguments["markdown"]?.ToString());
+    }
+
+    [Fact]
+    public async Task ClientUsesNonStreamingResponsesWhenConfigured()
+    {
+        var handler = new RecordingHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new StringContent(
+                """
+                {
+                  "id": "resp_nonstream",
                   "created_at": 1779147100,
-              "model": "gpt-5.5-2026-04-23",
+                  "model": "gpt-5.5",
+                  "object": "response",
                   "output": [
                     {
-                  "type": "reasoning",
+                      "id": "msg_nonstream",
-                  "summary": [],
-                  "status": null
-                },
-                {
                       "type": "message",
-                  "role": "assistant",
                       "status": "completed",
                       "content": [
                         {
                           "type": "output_text",
-                      "text": "OK"
+                          "annotations": [],
+                          "text": "Non-streamed OK"
                         }
-                  ]
+                      ],
+                      "role": "assistant"
                     }
-              ]
+                  ],
+                  "parallel_tool_calls": true,
+                  "status": "completed",
+                  "store": false,
+                  "usage": {
+                    "input_tokens": 12,
+                    "output_tokens": 4,
+                    "total_tokens": 16
                   }
-            """;
+                }
+                """,
+                Encoding.UTF8,
+                "application/json")
+        });
+        using var client = CreateClient(handler, reconnectionAttempts: 0, useStreaming: false);
 
-        var response = LiteLlmResponsesChatClient.ParseResponseJson(json);
+        var response = await client.GetResponseAsync([new ChatMessage(ChatRole.User, "reply")]);
 
-        Assert.Equal("OK", response.Text);
+        Assert.Equal("Non-streamed OK", response.Text);
-        Assert.Equal("resp_test", response.ResponseId);
+        Assert.Contains("\"stream\":false", Assert.Single(handler.RequestBodies));
-        Assert.Equal("gpt-5.5-2026-04-23", response.ModelId);
+    }
+
+    [Fact]
+    public async Task ClientSendsChatMessagesAsResponsesMessageItems()
+    {
+        var handler = new RecordingHttpMessageHandler(_ => CreateStreamedTextResponse("Done."));
+        using var client = CreateClient(handler, reconnectionAttempts: 0);
+
+        await client.GetResponseAsync(
+        [
+            new ChatMessage(ChatRole.User, "write summary"),
+            new ChatMessage(ChatRole.Assistant, "I will inspect the meeting.")
+        ]);
+
+        using var request = JsonDocument.Parse(Assert.Single(handler.RequestBodies));
+        var inputItems = request.RootElement.GetProperty("input").EnumerateArray().ToArray();
+        Assert.Equal(2, inputItems.Length);
+        Assert.All(inputItems, item => Assert.Equal("message", item.GetProperty("type").GetString()));
+        Assert.Equal("user", inputItems[0].GetProperty("role").GetString());
+        Assert.Equal(
+            "input_text",
+            Assert.Single(inputItems[0].GetProperty("content").EnumerateArray())
+                .GetProperty("type")
+                .GetString());
+        Assert.Equal("assistant", inputItems[1].GetProperty("role").GetString());
+        Assert.Equal(
+            "output_text",
+            Assert.Single(inputItems[1].GetProperty("content").EnumerateArray())
+                .GetProperty("type")
+                .GetString());
+        Assert.DoesNotContain("\"type\":\"unknown\"", handler.RequestBodies[0]);
+    }
+
+    [Fact]
+    public async Task AgentLoopReturnsMalformedFunctionArgumentsWithoutInvokingTool()
+    {
+        var responses = new Queue<HttpResponseMessage>(
+        [
+            new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(
+                    """
+                    data: {"type":"response.output_item.done","output_index":0,"item":{"type":"function_call","call_id":"call_invalid","name":"write_summary","arguments":"{not-json","status":"completed"}}
+
+                    data: {"type":"response.completed","response":{"id":"resp_invalid","model":"gpt-5.5","output":[]}}
+
+                    data: [DONE]
+
+                    """,
+                    Encoding.UTF8,
+                    "text/event-stream")
+            },
+            CreateStreamedTextResponse("Recovered.")
+        ]);
+        var handler = new RecordingHttpMessageHandler(_ => responses.Dequeue());
+        var toolInvoked = false;
+        var tool = AIFunctionFactory.Create(
+            (string markdown) =>
+            {
+                toolInvoked = true;
+                return markdown;
+            },
+            "write_summary",
+            "Writes a summary.");
+        using var innerClient = CreateClient(handler, reconnectionAttempts: 0);
+        using var functionClient = innerClient
+            .AsBuilder()
+            .UseFunctionInvocation(
+                loggerFactory: null,
+                client => client.FunctionInvoker = FunctionInvocationGuard.InvokeAsync)
+            .Build();
+
+        var response = await functionClient.GetResponseAsync(
+            [new ChatMessage(ChatRole.User, "write summary")],
+            new ChatOptions { Tools = [tool] });
+
+        Assert.False(toolInvoked);
+        Assert.Equal("Recovered.", response.Text);
+        Assert.Equal(2, handler.RequestBodies.Count);
+        Assert.Contains("invalid_tool_arguments", handler.RequestBodies[1]);
+        Assert.Contains("call_invalid", handler.RequestBodies[1]);
     }
 
     [Fact]
     public async Task ClientReportsVisibleReasoningSummariesSeparatelyFromResponseText()
     {
         var handler = new SequencedHttpMessageHandler(
-            new HttpResponseMessage(HttpStatusCode.OK)
+            CreateStreamedTextResponse(
-            {
+                "Done.",
-                Content = new StringContent("""
+                "Checked the configured rules file.",
-                    {
+                "Prepared a targeted update."));
-                      "output": [
-                        {
-                          "type": "reasoning",
-                          "summary": [
-                            {
-                              "type": "summary_text",
-                              "text": "Checked the configured rules file."
-                            },
-                            {
-                              "type": "summary_text",
-                              "text": "Prepared a targeted update."
-                            }
-                          ]
-                        },
-                        {
-                          "type": "message",
-                          "content": [
-                            {
-                              "type": "output_text",
-                              "text": "Done."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                    """)
-            });
         var reasoningSummaries = new List<string>();
         using var client = CreateClient(
             handler,
@@ -98,33 +239,7 @@ public sealed class LiteLlmResponsesChatClientTests
     public async Task ClientDoesNotFailResponseWhenReasoningSummaryCallbackFails()
     {
         var handler = new SequencedHttpMessageHandler(
-            new HttpResponseMessage(HttpStatusCode.OK)
+            CreateStreamedTextResponse("Done.", "Checked the configured rules file."));
-            {
-                Content = new StringContent("""
-                    {
-                      "output": [
-                        {
-                          "type": "reasoning",
-                          "summary": [
-                            {
-                              "type": "summary_text",
-                              "text": "Checked the configured rules file."
-                            }
-                          ]
-                        },
-                        {
-                          "type": "message",
-                          "content": [
-                            {
-                              "type": "output_text",
-                              "text": "Done."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                    """)
-            });
         using var client = CreateClient(
             handler,
             reconnectionAttempts: 0,
@@ -135,64 +250,6 @@ public sealed class LiteLlmResponsesChatClientTests
         Assert.Equal("Done.", response.Text);
     }
 
-    [Fact]
-    public void ParserReadsFunctionCalls()
-    {
-        const string json = """
-            {
-              "output": [
-                {
-                  "type": "function_call",
-                  "call_id": "call_1",
-                  "name": "write_summary",
-                  "arguments": "{\"markdown\":\"# Summary\\nDone\"}",
-                  "status": "completed"
-                }
-              ]
-            }
-            """;
-
-        var response = LiteLlmResponsesChatClient.ParseResponseJson(json);
-        var call = Assert.IsType<FunctionCallContent>(Assert.Single(response.Messages[0].Contents));
-
-        Assert.Equal("call_1", call.CallId);
-        Assert.Equal("write_summary", call.Name);
-        Assert.NotNull(call.Arguments);
-        Assert.Equal("# Summary\nDone", call.Arguments["markdown"]);
-    }
-
-    [Fact]
-    public void ParserReadsUsage()
-    {
-        const string json = """
-            {
-              "usage": {
-                "input_tokens": 123,
-                "output_tokens": 45,
-                "total_tokens": 168
-              },
-              "output": [
-                {
-                  "type": "message",
-                  "content": [
-                    {
-                      "type": "output_text",
-                      "text": "OK"
-                    }
-                  ]
-                }
-              ]
-            }
-            """;
-
-        var response = LiteLlmResponsesChatClient.ParseResponseJson(json);
-
-        Assert.NotNull(response.Usage);
-        Assert.Equal(123, response.Usage.InputTokenCount);
-        Assert.Equal(45, response.Usage.OutputTokenCount);
-        Assert.Equal(168, response.Usage.TotalTokenCount);
-    }
-
     [Fact]
     public async Task ClientRetriesTransientServerFailure()
     {
@@ -201,24 +258,7 @@ public sealed class LiteLlmResponsesChatClientTests
             {
                 Content = new StringContent("Internal Server Error")
             },
-            new HttpResponseMessage(HttpStatusCode.OK)
+            CreateStreamedTextResponse("Done."));
-            {
-                Content = new StringContent("""
-                    {
-                      "output": [
-                        {
-                          "type": "message",
-                          "content": [
-                            {
-                              "type": "output_text",
-                              "text": "Done."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                    """)
-            });
         var retryCount = 0;
         using var client = CreateClient(handler, reconnectionAttempts: 1, retrying: () => retryCount++);
 
@@ -249,24 +289,7 @@ public sealed class LiteLlmResponsesChatClientTests
     [Fact]
     public async Task ClientSendsUserInitiatorOnceThenAgentInitiator()
     {
-        var handler = new RecordingHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        var handler = new RecordingHttpMessageHandler(_ => CreateStreamedTextResponse("Done."));
-        {
-            Content = new StringContent("""
-                {
-                  "output": [
-                    {
-                      "type": "message",
-                      "content": [
-                        {
-                          "type": "output_text",
-                          "text": "Done."
-                        }
-                      ]
-                    }
-                  ]
-                }
-                """)
-        });
         using var client = CreateClient(handler, reconnectionAttempts: 0);
 
         await client.GetResponseAsync([new ChatMessage(ChatRole.User, "write summary")]);
@@ -298,24 +321,7 @@ public sealed class LiteLlmResponsesChatClientTests
                 };
             }
 
-            return new HttpResponseMessage(HttpStatusCode.OK)
+            return CreateStreamedTextResponse("Done.");
-            {
-                Content = new StringContent("""
-                    {
-                      "output": [
-                        {
-                          "type": "message",
-                          "content": [
-                            {
-                              "type": "output_text",
-                              "text": "Done."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                    """)
-            };
         });
         using var client = CreateClient(
             handler,
@@ -350,24 +356,7 @@ public sealed class LiteLlmResponsesChatClientTests
                 };
             }
 
-            return new HttpResponseMessage(HttpStatusCode.OK)
+            return CreateStreamedTextResponse("Done.");
-            {
-                Content = new StringContent("""
-                    {
-                      "output": [
-                        {
-                          "type": "message",
-                          "content": [
-                            {
-                              "type": "output_text",
-                              "text": "Done."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                    """)
-            };
         });
         using var client = CreateClient(
             handler,
@@ -400,7 +389,8 @@ public sealed class LiteLlmResponsesChatClientTests
         int reconnectionAttempts,
         LiteLlmResponsesCompactionOptions? compactionOptions = null,
         Action? retrying = null,
-        Action<string>? reasoningSummaryChanged = null)
+        Action<string>? reasoningSummaryChanged = null,
+        bool useStreaming = true)
     {
         return new LiteLlmResponsesChatClient(
             new HttpClient(handler)
@@ -415,7 +405,49 @@ public sealed class LiteLlmResponsesChatClientTests
             TimeSpan.Zero,
             compactionOptions,
             retrying: retrying,
-            reasoningSummaryChanged: reasoningSummaryChanged);
+            reasoningSummaryChanged: reasoningSummaryChanged,
+            useStreaming: useStreaming);
+    }
+
+    private static HttpResponseMessage CreateStreamedTextResponse(
+        string text,
+        params string[] reasoningSummaries)
+    {
+        var events = new List<string>();
+        for (var index = 0; index < reasoningSummaries.Length; index++)
+        {
+            events.Add("data: " + JsonSerializer.Serialize(new
+            {
+                type = "response.reasoning_summary_text.delta",
+                item_id = "reasoning_stream",
+                output_index = 0,
+                summary_index = index,
+                delta = reasoningSummaries[index]
+            }));
+        }
+
+        var outputIndex = reasoningSummaries.Length > 0 ? 1 : 0;
+        events.Add("data: " + JsonSerializer.Serialize(new
+        {
+            type = "response.output_text.delta",
+            item_id = "msg_stream",
+            output_index = outputIndex,
+            content_index = 0,
+            delta = text
+        }));
+        events.Add(
+            """data: {"type":"response.completed","response":{"id":"resp_stream","created_at":1779147100,"model":"gpt-5.5","object":"response","output":[],"parallel_tool_calls":true,"status":"completed","store":false,"usage":{"input_tokens":12,"output_tokens":3,"total_tokens":15}}}""");
+        events.Add("data: [DONE]");
+
+        return new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new StringContent(
+                string.Join($"{Environment.NewLine}{Environment.NewLine}", events)
+                    + Environment.NewLine
+                    + Environment.NewLine,
+                Encoding.UTF8,
+                "text/event-stream")
+        };
     }
 
     private sealed class SequencedHttpMessageHandler : HttpMessageHandler

MeetingAssistant.Tests/MeetingSummaryInstructionBuilderTests.cs

@@ -40,6 +40,27 @@ public sealed class MeetingSummaryInstructionBuilderTests
         Assert.Contains("title parameter", instructions);
     }
 
+    [Fact]
+    public async Task DefaultPromptTreatsAssistantContextAsMeetingMemoryForUncertainty()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        var artifacts = CreateArtifacts(root);
+        await WriteMeetingNoteAsync(artifacts.MeetingNotePath, []);
+        var builder = new MeetingSummaryInstructionBuilder(Options.Create(new MeetingAssistantOptions
+        {
+            Agent = new AgentOptions { InitialPrompt = " " },
+            Vault = new VaultOptions { ProjectsFolder = Path.Combine(root, "Projects") }
+        }));
+
+        var instructions = await builder.BuildAsync(artifacts, CancellationToken.None);
+
+        Assert.Contains("meeting-specific memory", instructions);
+        Assert.Contains("unexpected problems", instructions);
+        Assert.Contains("missing information", instructions);
+        Assert.Contains("assumptions", instructions);
+        Assert.Contains("write_context", instructions);
+    }
+
     [Fact]
     public async Task BuilderUsesConfiguredPrompt()
     {

MeetingAssistant.Tests/WorkflowRulesEditorTests.cs

@@ -20,6 +20,7 @@ public sealed class WorkflowRulesEditorTests
             Key = "summary-key",
             KeyEnv = "SUMMARY_KEY",
             Model = "summary-model",
+            UseStreaming = true,
             EnableThinking = true,
             ReasoningEffort = ReasoningEffortOption.High,
             ReconnectionAttempts = 7,
@@ -33,6 +34,7 @@ public sealed class WorkflowRulesEditorTests
         var editor = new WorkflowRulesEditorOptions
         {
             Model = "editor-model",
+            UseStreaming = false,
             EnableThinking = false,
             MaxOutputTokens = 50
         };
@@ -43,6 +45,7 @@ public sealed class WorkflowRulesEditorTests
         Assert.Equal("summary-key", effective.Key);
         Assert.Equal("SUMMARY_KEY", effective.KeyEnv);
         Assert.Equal("editor-model", effective.Model);
+        Assert.False(effective.UseStreaming);
         Assert.False(effective.EnableThinking);
         Assert.Equal(ReasoningEffortOption.High, effective.ReasoningEffort);
         Assert.Equal(7, effective.ReconnectionAttempts);
@@ -760,6 +763,29 @@ public sealed class WorkflowRulesEditorTests
         Assert.Contains("matching correction", instructions);
     }
 
+    [Fact]
+    public async Task InstructionBuilderTreatsAssistantContextAsMeetingMemoryDuringRepairs()
+    {
+        var builder = new WorkflowRulesEditorInstructionBuilder(
+            NullLogger<WorkflowRulesEditorInstructionBuilder>.Instance);
+        var options = new MeetingAssistantOptions
+        {
+            WorkflowRulesEditor = new WorkflowRulesEditorOptions
+            {
+                InitialPrompt = "Custom interactive agent instructions."
+            }
+        };
+
+        var instructions = await builder.BuildAsync(options, CancellationToken.None);
+
+        Assert.Contains("Custom interactive agent instructions.", instructions);
+        Assert.Contains("meeting-specific memory", instructions);
+        Assert.Contains("fix or investigate a meeting or summary", instructions);
+        Assert.Contains("read the matching assistant context", instructions);
+        Assert.Contains("problems, missing information, assumptions, prior fixes, and conclusions", instructions);
+        Assert.Contains("append a concise record of your fixes and conclusions", instructions);
+    }
+
     [Fact]
     public async Task RulesEditorToolsCrudAndSearchSpeakerIdentities()
     {

MeetingAssistant/MeetingAssistant.csproj

@@ -28,7 +28,7 @@
     <PackageReference Include="NAudio" Version="2.3.0" />
     <PackageReference Include="NCalcSync" Version="6.4.0" />
     <PackageReference Include="RazorLight" Version="2.3.1" />
-    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.3" />
+    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.5" />
     <PackageReference Include="System.Drawing.Common" Version="10.0.10" />
     <PackageReference Include="Whisper.net" Version="1.9.1" />
     <PackageReference Include="Whisper.net.Runtime" Version="1.9.1" />

MeetingAssistant/MeetingAssistantOptions.cs

@@ -383,6 +383,8 @@ public sealed class AgentOptions
 
     public string Model { get; set; } = "chatgpt/gpt-5.5";
 
+    public bool UseStreaming { get; set; } = true;
+
     public bool EnableThinking { get; set; } = true;
 
     public ReasoningEffortOption ReasoningEffort { get; set; } = ReasoningEffortOption.Medium;
@@ -414,6 +416,8 @@ public sealed class WorkflowRulesEditorOptions
 
     public string? Model { get; set; }
 
+    public bool? UseStreaming { get; set; }
+
     public bool? EnableThinking { get; set; }
 
     public ReasoningEffortOption? ReasoningEffort { get; set; }
@@ -442,6 +446,7 @@ public sealed class WorkflowRulesEditorOptions
             Key = string.IsNullOrWhiteSpace(Key) ? defaults.Key : Key,
             KeyEnv = string.IsNullOrWhiteSpace(KeyEnv) ? defaults.KeyEnv : KeyEnv!,
             Model = string.IsNullOrWhiteSpace(Model) ? defaults.Model : Model!,
+            UseStreaming = UseStreaming ?? defaults.UseStreaming,
             EnableThinking = EnableThinking ?? defaults.EnableThinking,
             ReasoningEffort = ReasoningEffort ?? defaults.ReasoningEffort,
             ReconnectionAttempts = ReconnectionAttempts ?? defaults.ReconnectionAttempts,

MeetingAssistant/Summary/FunctionInvocationGuard.cs

@@ -0,0 +1,26 @@
+using System.Text.Json.Nodes;
+using Microsoft.Extensions.AI;
+
+namespace MeetingAssistant.Summary;
+
+internal static class FunctionInvocationGuard
+{
+    public static ValueTask<object?> InvokeAsync(
+        FunctionInvocationContext context,
+        CancellationToken cancellationToken)
+    {
+        if (context.CallContent.Exception is not null)
+        {
+            return ValueTask.FromResult<object?>(new JsonObject
+            {
+                ["error"] = new JsonObject
+                {
+                    ["code"] = "invalid_tool_arguments",
+                    ["message"] = "Tool arguments must be a valid JSON object."
+                }
+            });
+        }
+
+        return context.Function.InvokeAsync(context.Arguments, cancellationToken);
+    }
+}

MeetingAssistant/Summary/LiteLlmResponsesChatClient.cs

@@ -1,20 +1,28 @@
 using System.Net.Http.Headers;
+using System.ClientModel;
+using System.ClientModel.Primitives;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using Microsoft.Agents.AI.Compaction;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Logging;
+using OpenAI;
+using OpenAI.Responses;
 
 namespace MeetingAssistant.Summary;
 
 #pragma warning disable MAAI001
+#pragma warning disable OPENAI001
 public sealed class LiteLlmResponsesChatClient : IChatClient
 {
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
 
     private readonly HttpClient httpClient;
+    private readonly ResponsesClient responsesClient;
+    private readonly AsyncLocal<string?> requestInitiator = new();
     private readonly string model;
+    private readonly bool useStreaming;
     private readonly bool enableThinking;
     private readonly string reasoningEffort;
     private readonly int reconnectionAttempts;
@@ -37,7 +45,8 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         ILogger? logger = null,
         bool firstRequestIsUser = true,
         Action? retrying = null,
-        Action<string>? reasoningSummaryChanged = null)
+        Action<string>? reasoningSummaryChanged = null,
+        bool useStreaming = true)
         : this(
             new HttpClient { BaseAddress = NormalizeEndpoint(endpoint) },
             apiKey,
@@ -50,7 +59,8 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
             logger,
             firstRequestIsUser,
             retrying,
-            reasoningSummaryChanged)
+            reasoningSummaryChanged,
+            useStreaming)
     {
     }
 
@@ -66,11 +76,14 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         ILogger? logger = null,
         bool firstRequestIsUser = true,
         Action? retrying = null,
-        Action<string>? reasoningSummaryChanged = null)
+        Action<string>? reasoningSummaryChanged = null,
+        bool useStreaming = true)
     {
         this.httpClient = httpClient;
         this.httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
+        responsesClient = CreateResponsesClient(httpClient, apiKey, requestInitiator);
         this.model = model;
+        this.useStreaming = useStreaming;
         this.enableThinking = enableThinking;
         this.reasoningEffort = reasoningEffort;
         this.reconnectionAttempts = Math.Max(0, reconnectionAttempts);
@@ -87,20 +100,50 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         httpClient.Dispose();
     }
 
+    internal static LiteLlmResponsesChatClient Create(
+        AgentOptions options,
+        string apiKey,
+        LiteLlmResponsesCompactionOptions? compactionOptions,
+        ILogger? logger,
+        bool firstRequestIsUser,
+        Action? retrying = null,
+        Action<string>? reasoningSummaryChanged = null)
+    {
+        return new LiteLlmResponsesChatClient(
+            new Uri(options.Endpoint),
+            apiKey,
+            options.Model,
+            options.EnableThinking,
+            options.ReasoningEffort switch
+            {
+                ReasoningEffortOption.None => "none",
+                ReasoningEffortOption.Low => "low",
+                ReasoningEffortOption.High => "high",
+                ReasoningEffortOption.ExtraHigh => "xhigh",
+                _ => "medium"
+            },
+            options.ReconnectionAttempts,
+            options.ReconnectionDelay,
+            compactionOptions,
+            logger,
+            firstRequestIsUser,
+            retrying,
+            reasoningSummaryChanged,
+            options.UseStreaming);
+    }
+
     public async Task<ChatResponse> GetResponseAsync(
         IEnumerable<ChatMessage> messages,
         ChatOptions? options = null,
         CancellationToken cancellationToken = default)
     {
         var payload = await CreateCompactedPayloadAsync(messages.ToList(), options, cancellationToken).ConfigureAwait(false);
-        var responseJson = await PostWithRetryAsync(payload, cancellationToken).ConfigureAwait(false);
+        var result = await PostWithRetryAsync(payload, cancellationToken).ConfigureAwait(false);
-
+        ReportVisibleReasoningSummaries(result.ReasoningSummaries);
-        var response = ParseResponseJson(responseJson, out var reasoningSummaries);
+        LogResponseDiagnostics(result.Response);
-        ReportVisibleReasoningSummaries(reasoningSummaries);
+        ThrowIfResponseHasNoContent(result.Response);
-        LogResponseDiagnostics(responseJson, response);
+        LogResponseUsage(result.Response.Usage);
-        ThrowIfResponseHasNoContent(responseJson, response);
+        return result.Response;
-        LogResponseUsage(response.Usage);
-        return response;
     }
 
     public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
@@ -127,79 +170,14 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
             : null;
     }
 
-    public static ChatResponse ParseResponseJson(string responseJson)
+    private static IReadOnlyList<string> ExtractVisibleReasoningSummaries(ChatResponse response)
     {
-        return ParseResponseJson(responseJson, out _);
+        return response.Messages
-    }
+            .SelectMany(message => message.Contents)
-
+            .OfType<TextReasoningContent>()
-    private static ChatResponse ParseResponseJson(
+            .Select(content => content.Text)
-        string responseJson,
+            .Where(text => !string.IsNullOrWhiteSpace(text))
-        out IReadOnlyList<string> reasoningSummaries)
+            .ToArray();
-    {
-        using var document = JsonDocument.Parse(responseJson);
-        var root = document.RootElement;
-        var contents = new List<AIContent>();
-        reasoningSummaries = ExtractVisibleReasoningSummaries(root);
-
-        if (root.TryGetProperty("output", out var output) && output.ValueKind == JsonValueKind.Array)
-        {
-            foreach (var item in output.EnumerateArray())
-            {
-                var type = GetString(item, "type");
-                if (type == "message")
-                {
-                    AddMessageContent(contents, item);
-                }
-                else if (type == "function_call")
-                {
-                    contents.Add(new FunctionCallContent(
-                        GetRequiredString(item, "call_id"),
-                        GetRequiredString(item, "name"),
-                        ParseArguments(GetString(item, "arguments"))));
-                }
-            }
-        }
-
-        var message = new ChatMessage
-        {
-            Role = ChatRole.Assistant,
-            Contents = contents
-        };
-
-        return new ChatResponse(message)
-        {
-            ResponseId = GetString(root, "id"),
-            ModelId = GetString(root, "model"),
-            CreatedAt = GetUnixTimestamp(root, "created_at"),
-            Usage = ParseUsage(root),
-            RawRepresentation = responseJson
-        };
-    }
-
-    internal static IReadOnlyList<string> ExtractVisibleReasoningSummaries(string responseJson)
-    {
-        using var document = JsonDocument.Parse(responseJson);
-        return ExtractVisibleReasoningSummaries(document.RootElement);
-    }
-
-    private static IReadOnlyList<string> ExtractVisibleReasoningSummaries(JsonElement root)
-    {
-        var summaries = new List<string>();
-
-        if (!root.TryGetProperty("output", out var output) || output.ValueKind != JsonValueKind.Array)
-        {
-            return summaries;
-        }
-
-        foreach (var item in output.EnumerateArray())
-        {
-            if (GetString(item, "type") == "reasoning")
-            {
-                AddVisibleReasoningSummaryText(summaries, item);
-            }
-        }
-
-        return summaries;
     }
 
     private void ReportVisibleReasoningSummaries(IReadOnlyList<string> summaries)
@@ -407,7 +385,9 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         return payload;
     }
 
-    private async Task<string> PostWithRetryAsync(JsonObject payload, CancellationToken cancellationToken)
+    private async Task<ResponsesChatResult> PostWithRetryAsync(
+        JsonObject payload,
+        CancellationToken cancellationToken)
     {
         var payloadJson = payload.ToJsonString(JsonOptions);
         Exception? lastException = null;
@@ -418,26 +398,36 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
             {
                 var initiator = NextInitiator();
                 LogRequestDiagnostics(payload, initiator, attempt);
-                using var request = CreateJsonRequest(
-                    "responses",
-                    payloadJson,
-                    initiator);
-                using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
-                var responseJson = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
 
-                if (response.IsSuccessStatusCode)
+                var createOptions = ModelReaderWriter.Read<CreateResponseOptions>(
+                        BinaryData.FromString(payloadJson),
+                        ModelReaderWriterOptions.Json)
+                    ?? throw new InvalidOperationException("Unable to create OpenAI Responses request options.");
+                createOptions.StreamingEnabled = useStreaming;
+
+                var previousInitiator = requestInitiator.Value;
+                requestInitiator.Value = initiator;
+                try
                 {
-                    return responseJson;
+                    return useStreaming
+                        ? await GetStreamingResponseAsync(createOptions, cancellationToken).ConfigureAwait(false)
+                        : CreateNonStreamingResult((await responsesClient
+                                .CreateResponseAsync(createOptions, cancellationToken)
+                                .ConfigureAwait(false))
+                            .Value
+                            .AsChatResponse(createOptions));
                 }
-
+                finally
-                var exception = new InvalidOperationException(
-                    $"LiteLLM Responses request failed with {(int)response.StatusCode} {response.ReasonPhrase}: {responseJson}");
-                if (!IsRetryableStatusCode((int)response.StatusCode) || attempt == reconnectionAttempts)
                 {
-                    throw exception;
+                    requestInitiator.Value = previousInitiator;
                 }
-
+            }
-                lastException = exception;
+            catch (ClientResultException exception)
+                when (!IsRetryableStatusCode(exception.Status) || attempt == reconnectionAttempts)
+            {
+                throw new InvalidOperationException(
+                    $"LiteLLM Responses request failed with {exception.Status}: {exception.Message}",
+                    exception);
             }
             catch (Exception exception) when (IsRetryableException(exception) && attempt < reconnectionAttempts)
             {
@@ -451,6 +441,48 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         throw lastException ?? new InvalidOperationException("LiteLLM Responses request failed.");
     }
 
+    private async Task<ResponsesChatResult> GetStreamingResponseAsync(
+        CreateResponseOptions createOptions,
+        CancellationToken cancellationToken)
+    {
+        var updates = new List<ChatResponseUpdate>();
+        var reasoningSummaries = new Dictionary<(string ItemId, int SummaryIndex), StringBuilder>();
+        await foreach (var update in responsesClient
+                           .CreateResponseStreamingAsync(createOptions, cancellationToken)
+                           .AsChatResponseUpdatesAsync(createOptions, cancellationToken)
+                           .ConfigureAwait(false))
+        {
+            updates.Add(update);
+            var reasoningUpdate = update.RawRepresentation
+                as StreamingResponseReasoningSummaryTextDeltaUpdate;
+            if (reasoningUpdate is null)
+            {
+                continue;
+            }
+
+            var key = (reasoningUpdate.ItemId, reasoningUpdate.SummaryIndex);
+            if (!reasoningSummaries.TryGetValue(key, out var summary))
+            {
+                summary = new StringBuilder();
+                reasoningSummaries[key] = summary;
+            }
+
+            summary.Append(reasoningUpdate.Delta);
+        }
+
+        return new ResponsesChatResult(
+            updates.ToChatResponse(),
+            reasoningSummaries.Values
+                .Select(summary => summary.ToString())
+                .Where(summary => !string.IsNullOrWhiteSpace(summary))
+                .ToArray());
+    }
+
+    private static ResponsesChatResult CreateNonStreamingResult(ChatResponse response)
+    {
+        return new ResponsesChatResult(response, ExtractVisibleReasoningSummaries(response));
+    }
+
     private HttpRequestMessage CreateJsonRequest(
         string requestUri,
         string payloadJson,
@@ -489,7 +521,9 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
 
     private static bool IsRetryableException(Exception exception)
     {
-        return exception is HttpRequestException or TaskCanceledException;
+        return exception is ClientResultException clientException
+                && IsRetryableStatusCode(clientException.Status)
+            || exception is HttpRequestException or TaskCanceledException;
     }
 
     private void LogContextWindow(int estimatedTokens, bool compacted, string source)
@@ -561,18 +595,18 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
             instructionsPreview);
     }
 
-    private void LogResponseDiagnostics(string responseJson, ChatResponse response)
+    private void LogResponseDiagnostics(ChatResponse response)
     {
         if (logger is null)
         {
             return;
         }
 
-        var outputTypes = GetOutputItemTypes(responseJson);
         var parsedTypes = response.Messages
             .SelectMany(message => message.Contents)
             .Select(content => content.GetType().Name)
             .ToArray();
+        var outputTypes = GetOutputItemTypes(response);
         var functionCalls = response.Messages
             .SelectMany(message => message.Contents)
             .OfType<FunctionCallContent>()
@@ -590,40 +624,29 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         if (parsedTypes.Length == 0)
         {
             logger.LogWarning(
-                "LiteLLM Responses response contained no parseable message text or function calls. Raw response preview: {ResponsePreview}",
+                "LiteLLM Responses response contained no parseable message text or function calls.");
-                Truncate(responseJson, maxLength: 6000));
         }
     }
 
-    private static void ThrowIfResponseHasNoContent(string responseJson, ChatResponse response)
+    private static void ThrowIfResponseHasNoContent(ChatResponse response)
     {
         if (response.Messages.SelectMany(message => message.Contents).Any())
         {
             return;
         }
 
-        var outputTypes = GetOutputItemTypes(responseJson);
+        var outputTypes = GetOutputItemTypes(response);
         throw new InvalidOperationException(
             "LiteLLM Responses returned no parseable message text or function calls. " +
             $"ResponseId={response.ResponseId ?? "<none>"}, outputTypes=[{string.Join(", ", outputTypes)}].");
     }
 
-    private static string[] GetOutputItemTypes(string responseJson)
+    private static string[] GetOutputItemTypes(ChatResponse response)
     {
-        try
+        return response.Messages
-        {
+            .SelectMany(message => message.Contents)
-            using var document = JsonDocument.Parse(responseJson);
+            .Select(content => content.RawRepresentation?.GetType().Name ?? content.GetType().Name)
-            return document.RootElement.TryGetProperty("output", out var output) && output.ValueKind == JsonValueKind.Array
+            .ToArray();
-                ? output
-                    .EnumerateArray()
-                    .Select(item => GetString(item, "type") ?? item.ValueKind.ToString())
-                    .ToArray()
-                : [];
-        }
-        catch (JsonException)
-        {
-            return ["<invalid-json>"];
-        }
     }
 
     private static string Truncate(string value, int maxLength)
@@ -649,10 +672,19 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
 
         if (!string.IsNullOrWhiteSpace(text))
         {
+            var isAssistant = role == ChatRole.Assistant.Value;
             input.Add(new JsonObject
             {
-                ["role"] = role == ChatRole.Assistant.Value ? "assistant" : "user",
+                ["type"] = "message",
-                ["content"] = text
+                ["role"] = isAssistant ? "assistant" : "user",
+                ["content"] = new JsonArray
+                {
+                    new JsonObject
+                    {
+                        ["type"] = isAssistant ? "output_text" : "input_text",
+                        ["text"] = text
+                    }
+                }
             });
         }
 
@@ -665,7 +697,7 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
                     ["type"] = "function_call",
                     ["call_id"] = call.CallId,
                     ["name"] = call.Name,
-                    ["arguments"] = JsonSerializer.Serialize(call.Arguments, JsonOptions)
+                    ["arguments"] = SerializeFunctionArguments(call)
                 });
             }
             else if (content is FunctionResultContent result)
@@ -702,110 +734,15 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         return result;
     }
 
-    private static void AddMessageContent(List<AIContent> contents, JsonElement item)
+    private static string SerializeFunctionArguments(FunctionCallContent call)
     {
-        if (!item.TryGetProperty("content", out var messageContent) || messageContent.ValueKind != JsonValueKind.Array)
+        if (call.RawRepresentation is FunctionCallResponseItem responseItem
+            && responseItem.FunctionArguments is not null)
         {
-            return;
+            return responseItem.FunctionArguments.ToString();
         }
 
-        foreach (var content in messageContent.EnumerateArray())
+        return JsonSerializer.Serialize(call.Arguments, JsonOptions);
-        {
-            if (GetString(content, "type") == "output_text")
-            {
-                var text = GetString(content, "text");
-                if (!string.IsNullOrEmpty(text))
-                {
-                    contents.Add(new TextContent(text));
-                }
-            }
-        }
-    }
-
-    private static void AddVisibleReasoningSummaryText(List<string> summaries, JsonElement item)
-    {
-        AddVisibleReasoningSummaryText(summaries, item, "summary");
-        AddVisibleReasoningSummaryText(summaries, item, "content");
-    }
-
-    private static void AddVisibleReasoningSummaryText(
-        List<string> summaries,
-        JsonElement item,
-        string propertyName)
-    {
-        if (!item.TryGetProperty(propertyName, out var property))
-        {
-            return;
-        }
-
-        if (property.ValueKind == JsonValueKind.String)
-        {
-            AddNonEmpty(summaries, property.GetString());
-            return;
-        }
-
-        if (property.ValueKind != JsonValueKind.Array)
-        {
-            return;
-        }
-
-        foreach (var summaryItem in property.EnumerateArray())
-        {
-            if (summaryItem.ValueKind == JsonValueKind.String)
-            {
-                AddNonEmpty(summaries, summaryItem.GetString());
-            }
-            else if (summaryItem.ValueKind == JsonValueKind.Object)
-            {
-                if (propertyName == "content" && !IsSummaryContent(summaryItem))
-                {
-                    continue;
-                }
-
-                AddNonEmpty(summaries, GetString(summaryItem, "text"));
-            }
-        }
-    }
-
-    private static bool IsSummaryContent(JsonElement item)
-    {
-        var type = GetString(item, "type");
-        return !string.IsNullOrWhiteSpace(type)
-            && type.Contains("summary", StringComparison.OrdinalIgnoreCase);
-    }
-
-    private static void AddNonEmpty(List<string> values, string? value)
-    {
-        if (!string.IsNullOrWhiteSpace(value))
-        {
-            values.Add(value.Trim());
-        }
-    }
-
-    private static Dictionary<string, object?> ParseArguments(string? arguments)
-    {
-        if (string.IsNullOrWhiteSpace(arguments))
-        {
-            return [];
-        }
-
-        using var document = JsonDocument.Parse(arguments);
-        return document.RootElement.EnumerateObject()
-            .ToDictionary(property => property.Name, property => ConvertJsonValue(property.Value));
-    }
-
-    private static object? ConvertJsonValue(JsonElement element)
-    {
-        return element.ValueKind switch
-        {
-            JsonValueKind.String => element.GetString(),
-            JsonValueKind.Number when element.TryGetInt64(out var integer) => integer,
-            JsonValueKind.Number when element.TryGetDouble(out var number) => number,
-            JsonValueKind.True => true,
-            JsonValueKind.False => false,
-            JsonValueKind.Null => null,
-            _ => JsonSerializer.Deserialize<object>(element.GetRawText(), JsonOptions)
-        };
     }
 
     private static string ResultToString(object? result)
@@ -818,57 +755,12 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         };
     }
 
-    private static UsageDetails? ParseUsage(JsonElement root)
-    {
-        if (!root.TryGetProperty("usage", out var usage) || usage.ValueKind != JsonValueKind.Object)
-        {
-            return null;
-        }
-
-        var inputTokens = GetInt(usage, "input_tokens") ?? GetInt(usage, "prompt_tokens");
-        var outputTokens = GetInt(usage, "output_tokens") ?? GetInt(usage, "completion_tokens");
-        var totalTokens = GetInt(usage, "total_tokens");
-        return new UsageDetails
-        {
-            InputTokenCount = inputTokens,
-            OutputTokenCount = outputTokens,
-            TotalTokenCount = totalTokens
-        };
-    }
-
     private static int EstimateTokens(JsonObject payload)
     {
         var json = payload.ToJsonString(JsonOptions);
         return Math.Max(1, (int)Math.Ceiling(json.Length / 4.0));
     }
 
-    private static int? GetInt(JsonElement element, string propertyName)
-    {
-        return element.TryGetProperty(propertyName, out var property) && property.TryGetInt32(out var value)
-            ? value
-            : null;
-    }
-
-    private static string GetRequiredString(JsonElement element, string propertyName)
-    {
-        return GetString(element, propertyName)
-            ?? throw new InvalidOperationException($"LiteLLM response item did not include '{propertyName}'.");
-    }
-
-    private static string? GetString(JsonElement element, string propertyName)
-    {
-        return element.TryGetProperty(propertyName, out var property) && property.ValueKind == JsonValueKind.String
-            ? property.GetString()
-            : null;
-    }
-
-    private static DateTimeOffset? GetUnixTimestamp(JsonElement element, string propertyName)
-    {
-        return element.TryGetProperty(propertyName, out var property) && property.TryGetInt64(out var value)
-            ? DateTimeOffset.FromUnixTimeSeconds(value)
-            : null;
-    }
-
     private static Uri NormalizeEndpoint(Uri endpoint)
     {
         var value = endpoint.ToString().TrimEnd('/');
@@ -884,5 +776,60 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
     {
         return value.TrimStart('/');
     }
+
+    private static ResponsesClient CreateResponsesClient(
+        HttpClient httpClient,
+        string apiKey,
+        AsyncLocal<string?> requestInitiator)
+    {
+        var options = new OpenAIClientOptions
+        {
+            Endpoint = httpClient.BaseAddress
+                ?? throw new InvalidOperationException("LiteLLM HTTP client requires a base address."),
+            Transport = new HttpClientPipelineTransport(httpClient),
+            RetryPolicy = new ClientRetryPolicy(0)
+        };
+        options.AddPolicy(
+            new InitiatorHeaderPolicy(requestInitiator),
+            PipelinePosition.PerCall);
+
+        return new ResponsesClient(
+            new ApiKeyCredential(apiKey),
+            options);
     }
+
+    private sealed record ResponsesChatResult(
+        ChatResponse Response,
+        IReadOnlyList<string> ReasoningSummaries);
+
+    private sealed class InitiatorHeaderPolicy(AsyncLocal<string?> requestInitiator) : PipelinePolicy
+    {
+        public override void Process(
+            PipelineMessage message,
+            IReadOnlyList<PipelinePolicy> pipeline,
+            int currentIndex)
+        {
+            SetHeader(message);
+            ProcessNext(message, pipeline, currentIndex);
+        }
+
+        public override ValueTask ProcessAsync(
+            PipelineMessage message,
+            IReadOnlyList<PipelinePolicy> pipeline,
+            int currentIndex)
+        {
+            SetHeader(message);
+            return ProcessNextAsync(message, pipeline, currentIndex);
+        }
+
+        private void SetHeader(PipelineMessage message)
+        {
+            if (!string.IsNullOrWhiteSpace(requestInitiator.Value))
+            {
+                message.Request.Headers.Set("X-Initiator", requestInitiator.Value);
+            }
+        }
+    }
+}
+#pragma warning restore OPENAI001
 #pragma warning restore MAAI001

MeetingAssistant/Summary/MeetingSummaryInstructionBuilder.cs

@@ -14,7 +14,7 @@ public sealed class MeetingSummaryInstructionBuilder : IMeetingSummaryInstructio
         write_summary is only for the current meeting's summary file. Past project meeting summaries are read-only historical context; use list_past_project_meetings and read_past_project_meeting_summary to inspect them, and never try to mutate them.
         If the meeting note has no title, or still has a generated default title like `Meeting yyyy-MM-dd HH:mm`, provide a concise title parameter to write_summary when the purpose of the meeting is clear from transcript, user notes, or assistant context. If the purpose is not clear, omit the title parameter.
         Use read_meetingnote to inspect frontmatter such as title, attendees, projects, start_time, and end_time.
-        Use read_context and write_context as your own meeting notebook. Its frontmatter may include agenda from the calendar appointment. Record useful internal notes, missing context, requests for future tools, suggested improvements, and relevant context discovered from other sources. write_context appends by default; use replace_file=true only when you are intentionally replacing the whole assistant context body. Keep user-facing summary content in the summary note.
+        Treat the assistant context as persistent meeting-specific memory and use read_context and write_context as your own meeting notebook. Its frontmatter may include agenda from the calendar appointment. Whenever you encounter unexpected problems, discover missing information, or make assumptions while summarizing, use write_context to append a concise note so later agents working on this meeting can understand them. Also record useful internal notes, requests for future tools, suggested improvements, and relevant context discovered from other sources. write_context appends by default; use replace_file=true only when you are intentionally replacing the whole assistant context body. Keep user-facing summary content in the summary note.
         Use add_dictation_word when project context, user notes, or transcript evidence show that a domain term, acronym, name, or unusual word is likely to be repeatedly mistranscribed. Add only the canonical spelling, one term at a time.
         Use add_attendee and remove_attendee to sharpen the meeting attendees list from clear transcript evidence and screenshot OCR participant evidence. Treat OCR that says visible people are a partial screenshot result as incomplete evidence; do not remove attendees solely because they are absent from a partial screenshot.
         Use override_speaker only when you are very certain that a transcript speaker label belongs to a named person, for example from user notes, OCR evidence with a matching timestamp, or very clear context cues. Provide the exact speaker label from the transcript and the replacement speaker name. If the replacement speaker already exists in the transcript, use merge=true only when you are certain both speaker labels are the same identity; otherwise do not merge them.

MeetingAssistant/Summary/OpenAiMeetingSummaryAgentPipeline.cs

@@ -63,32 +63,24 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
             meetingWorkflowEngine);
         var tools = CreateTools(meetingTools);
         var instructions = await instructionBuilder.BuildAsync(artifacts, options, cancellationToken);
-        using var compactionSummaryClient = new LiteLlmResponsesChatClient(
+        using var compactionSummaryClient = LiteLlmResponsesChatClient.Create(
-            new Uri(agentOptions.Endpoint),
+            agentOptions,
             key,
-            agentOptions.Model,
-            agentOptions.EnableThinking,
-            ToReasoningEffortValue(agentOptions.ReasoningEffort),
-            agentOptions.ReconnectionAttempts,
-            agentOptions.ReconnectionDelay,
             compactionOptions: null,
             logger,
             firstRequestIsUser: false);
         var compactionOptions = CreateCompactionOptions(agentOptions, compactionSummaryClient);
-        using var chatClient = new LiteLlmResponsesChatClient(
+        using var chatClient = LiteLlmResponsesChatClient.Create(
-            new Uri(agentOptions.Endpoint),
+            agentOptions,
             key,
-            agentOptions.Model,
-            agentOptions.EnableThinking,
-            ToReasoningEffortValue(agentOptions.ReasoningEffort),
-            agentOptions.ReconnectionAttempts,
-            agentOptions.ReconnectionDelay,
             compactionOptions,
             logger,
             firstRequestIsUser: false);
         var agent = chatClient
             .AsBuilder()
-            .UseFunctionInvocation()
+            .UseFunctionInvocation(
+                loggerFactory,
+                client => client.FunctionInvoker = FunctionInvocationGuard.InvokeAsync)
             .Build()
             .AsAIAgent(
                 instructions,
@@ -312,18 +304,6 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
         return new PipelineCompactionStrategy(strategies);
     }
 
-    private static string ToReasoningEffortValue(ReasoningEffortOption effort)
-    {
-        return effort switch
-        {
-            ReasoningEffortOption.None => "none",
-            ReasoningEffortOption.Low => "low",
-            ReasoningEffortOption.High => "high",
-            ReasoningEffortOption.ExtraHigh => "xhigh",
-            _ => "medium"
-        };
-    }
-
     private static ReasoningEffort ToReasoningEffort(ReasoningEffortOption effort)
     {
         return effort switch

MeetingAssistant/Workflow/WorkflowRulesEditorChatPipeline.cs

@@ -85,26 +85,16 @@ public sealed class WorkflowRulesEditorChatPipeline : IWorkflowRulesEditorChatPi
             .ToList();
         var instructions = await instructionBuilder.BuildAsync(options, cancellationToken);
 
-        using var compactionSummaryClient = new LiteLlmResponsesChatClient(
+        using var compactionSummaryClient = LiteLlmResponsesChatClient.Create(
-            new Uri(agentOptions.Endpoint),
+            agentOptions,
             key,
-            agentOptions.Model,
-            agentOptions.EnableThinking,
-            ToReasoningEffortValue(agentOptions.ReasoningEffort),
-            agentOptions.ReconnectionAttempts,
-            agentOptions.ReconnectionDelay,
             compactionOptions: null,
             logger,
             firstRequestIsUser: false);
         var compactionOptions = CreateCompactionOptions(agentOptions, compactionSummaryClient);
-        using var chatClient = new LiteLlmResponsesChatClient(
+        using var chatClient = LiteLlmResponsesChatClient.Create(
-            new Uri(agentOptions.Endpoint),
+            agentOptions,
             key,
-            agentOptions.Model,
-            agentOptions.EnableThinking,
-            ToReasoningEffortValue(agentOptions.ReasoningEffort),
-            agentOptions.ReconnectionAttempts,
-            agentOptions.ReconnectionDelay,
             compactionOptions,
             logger,
             firstRequestIsUser: true,
@@ -115,9 +105,13 @@ public sealed class WorkflowRulesEditorChatPipeline : IWorkflowRulesEditorChatPi
             .UseFunctionInvocation(loggerFactory, client =>
             {
                 client.FunctionInvoker = async (context, token) =>
+                {
+                    if (context.CallContent.Exception is null)
                     {
                         activityChanged?.Invoke(WorkflowRulesEditorActivityUpdate.ToolCall(context.Function.Name));
-                    return await context.Function.InvokeAsync(context.Arguments, token);
+                    }
+
+                    return await FunctionInvocationGuard.InvokeAsync(context, token);
                 };
             })
             .Build();
@@ -396,18 +390,6 @@ public sealed class WorkflowRulesEditorChatPipeline : IWorkflowRulesEditorChatPi
             $"No {agentName} API key configured. Set MeetingAssistant:WorkflowRulesEditor:Key, MeetingAssistant:Agent:Key, or environment variable '{options.KeyEnv}'.");
     }
 
-    private static string ToReasoningEffortValue(ReasoningEffortOption effort)
-    {
-        return effort switch
-        {
-            ReasoningEffortOption.None => "none",
-            ReasoningEffortOption.Low => "low",
-            ReasoningEffortOption.High => "high",
-            ReasoningEffortOption.ExtraHigh => "xhigh",
-            _ => "medium"
-        };
-    }
-
     private static ReasoningEffort ToReasoningEffort(ReasoningEffortOption effort)
     {
         return effort switch

MeetingAssistant/Workflow/WorkflowRulesEditorInstructionBuilder.cs

@@ -60,7 +60,7 @@ public sealed class WorkflowRulesEditorInstructionBuilder : IWorkflowRulesEditor
             "Log tools can read and search the current application-owned log file and four rotated older files under the temp log folder." + Environment.NewLine + Environment.NewLine +
             "Spec tools can search and read copied OpenSpec markdown files from openspec/specs." + Environment.NewLine + Environment.NewLine +
             "Project tools can create project folders and read, write, list, and search files in configured projects." + Environment.NewLine + Environment.NewLine +
-            "Meeting artifact tools can list recent summaries and read/search/write summaries, transcripts, meeting notes, and assistant context files for note post-processing and repair. Prefer frontmatter-specific write tools for metadata-only fixes." + Environment.NewLine + Environment.NewLine +
+            "Meeting artifact tools can list recent summaries and read/search/write summaries, transcripts, meeting notes, and assistant context files for note post-processing and repair. Prefer frontmatter-specific write tools for metadata-only fixes. Treat each assistant context file as meeting-specific memory. When asked to fix or investigate a meeting or summary, read the matching assistant context for clues about problems, missing information, assumptions, prior fixes, and conclusions. After completing repairs, use write_context to append a concise record of your fixes and conclusions to that assistant context for future work on the meeting." + Environment.NewLine + Environment.NewLine +
             "Diagnostic tools mirror the local health, recording status, Outlook metadata, speaker identity merge, workflow reload, and ASR diagnostic endpoints without requiring HTTP." + Environment.NewLine + Environment.NewLine +
             "Speaker identity tools can search/list/read/update/delete/merge identities, refuse sampleless identity creation, list/read/delete identity samples, and queue a sample for local playback. Do not delete the last sample from an identity; delete the identity instead." + Environment.NewLine + Environment.NewLine +
             "Workflow rules reference documentation:" + Environment.NewLine +

MeetingAssistant/appsettings.json

@@ -172,6 +172,7 @@
       "Endpoint": "http://127.0.0.1:4021",
       "KeyEnv": "LITELLM_API_KEY",
       "Model": "chatgpt/gpt-5.5",
+      "UseStreaming": true,
       "EnableThinking": true,
       "ReasoningEffort": "Medium",
       "ReconnectionAttempts": 2,

docs/meeting-assistant-configuration.md

@@ -339,6 +339,7 @@ When enabled on Windows, Meeting Assistant periodically syncs today's Outlook Cl
 | `Key` | Optional inline API key. Prefer `KeyEnv`. |
 | `KeyEnv` | Environment variable name for the agent API key. |
 | `Model` | Model id sent to the endpoint. |
+| `UseStreaming` | Uses the Responses SSE transport when `true` (the default); uses the non-streaming Responses transport when `false`. |
 | `EnableThinking` | Enables reasoning options in requests when supported by the model/backend. |
 | `ReasoningEffort` | Reasoning effort: `None`, `Low`, `Medium`, `High`, or `ExtraHigh`. |
 | `ReconnectionAttempts` | Retry count for transient model endpoint failures. |
@@ -352,18 +353,22 @@ When enabled on Windows, Meeting Assistant periodically syncs today's Outlook Cl
 
 After transcription has fully finished, Meeting Assistant automatically runs the summary pipeline for the meeting. The summary agent writes the full markdown summary through `write_summary` and must provide a required `oneliner` value, which is stored in summary frontmatter and must not contain line breaks.
 
+The built-in summary-agent instructions treat assistant context as persistent meeting-specific memory. When the agent encounters an unexpected problem, missing information, or an assumption while summarizing, it appends a concise note through `write_context` so later work on the same meeting can use that history. A configured `Agent:InitialPrompt` completely replaces the built-in instructions, so custom prompts must include equivalent guidance when this behavior is desired.
+
 The summary agent can add and remove meeting-note attendees when transcript or OCR evidence is clear. It can override transcript speaker labels only when the evidence is very certain, and it can delete wrongfully matched identities. Final speaker identity learning and candidate updates run after the summary pipeline finishes so they use the summary-refined attendee list and any recorded speaker identity changes.
 
 `ContextWindowTokens`, `MaxOutputTokens`, `EnableCompaction`, and `CompactionRemainingRatio` configure summary-agent context monitoring. Meeting Assistant estimates the outgoing Responses payload size, logs the estimated token count and remaining context, and compacts the conversation when only the configured remaining ratio is left.
 
 ## Workflow Rules Editor
 
-`WorkflowRulesEditor` configures the tray-launched `Meeting Summary Agent` window. Blank values inherit from `Agent`, so it uses the summarizer endpoint, key, model, reasoning, retry, output, and compaction settings unless explicitly overridden.
+`WorkflowRulesEditor` configures the tray-launched `Meeting Summary Agent` window. Blank values inherit from `Agent`, so it uses the summarizer endpoint, key, model, Responses transport, reasoning, retry, output, and compaction settings unless explicitly overridden.
 
-The overridable fields are `Endpoint`, `Key`, `KeyEnv`, `Model`, `EnableThinking`, `ReasoningEffort`, `ReconnectionAttempts`, `ReconnectionDelay`, `ContextWindowTokens`, `MaxOutputTokens`, `EnableCompaction`, `CompactionRemainingRatio`, `ResponsesCompactPath`, and `InitialPrompt`.
+The overridable fields are `Endpoint`, `Key`, `KeyEnv`, `Model`, `UseStreaming`, `EnableThinking`, `ReasoningEffort`, `ReconnectionAttempts`, `ReconnectionDelay`, `ContextWindowTokens`, `MaxOutputTokens`, `EnableCompaction`, `CompactionRemainingRatio`, `ResponsesCompactPath`, and `InitialPrompt`.
 
 The assistant can edit workflow rules, manage speaker identities, read and replace the local appsettings file, read this configuration document, search and read copied OpenSpec specs, inspect application logs, create/search/read/write project files, and post-process past meeting artifacts by listing recent summaries and reading, writing, or searching summaries, transcripts, meeting notes, and assistant context files. For artifact metadata repairs, it has frontmatter-specific write tools that preserve the markdown body.
 
+When asked to fix or investigate a meeting or summary, the agent is instructed to treat the matching assistant context as meeting-specific memory and read it for clues about problems, missing information, assumptions, prior fixes, and conclusions. After completing a repair, it appends a concise record of its fixes and conclusions to that context for future work on the meeting. This meeting-memory guidance is appended to the effective interactive-agent prompt even when `WorkflowRulesEditor:InitialPrompt` is configured.
+
 It also has in-process diagnostic tools that mirror the local HTTP diagnostics for health, recording status, current Outlook meeting lookup, recent speaker identity merging, workflow configuration reload, and ASR transcribe/diarize checks.
 
 The `search_spec` and `read_spec_file` tools are scoped to the copied `openspec/specs` markdown tree. Spec files are copied into build and publish output through an MSBuild glob, so newly added folders under `openspec/specs` are included automatically.

docs/meeting-workflow-engine.md

@@ -31,6 +31,7 @@ The tray menu includes `Open agent`, which opens the `Meeting Summary Agent` cha
       "Endpoint": "",
       "KeyEnv": "",
       "Model": "",
+      "UseStreaming": null,
       "EnableThinking": null,
       "ReasoningEffort": null,
       "MaxOutputTokens": null,

openspec/changes/archive/2026-07-17-use-assistant-context-as-meeting-memory/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-07-17

openspec/changes/archive/2026-07-17-use-assistant-context-as-meeting-memory/design.md

@@ -0,0 +1,45 @@
+## Context
+
+Meeting Assistant already creates one assistant context artifact per meeting and gives both the automatic summary agent and the interactive agent window tools that can read and append to it. The current summary prompt calls the file a notebook, while the interactive agent prompt describes only generic artifact repair. Neither prompt establishes assistant context as the durable handoff point for uncertainty, failures, assumptions, repairs, and conclusions about one meeting.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- Make the assistant context's meeting-specific memory role explicit to both agents.
+- Preserve summarization problems, missing information, and assumptions for later investigation.
+- Make the interactive agent consult that memory before repairing a meeting or summary.
+- Make the interactive agent record completed fixes and conclusions for later agents.
+
+**Non-Goals:**
+
+- Add a new artifact type, schema, section format, or database.
+- Automatically rewrite or summarize existing assistant context files.
+- Change tool permissions or allow agents to access artifacts outside existing configured scopes.
+- Override an explicitly configured custom summary-agent prompt with built-in summary guidance.
+
+## Decisions
+
+### Extend the existing instruction builders
+
+The automatic summary behavior will be added to `MeetingSummaryInstructionBuilder.DefaultInitialPrompt`. This preserves the existing contract that a configured `Agent:InitialPrompt` replaces the built-in summary prompt.
+
+The interactive behavior will be included in the instruction builder's always-appended meeting-artifact guidance. This keeps the meeting-memory reminder available even when the interactive agent has a custom initial prompt, alongside the tool capabilities that Meeting Assistant already appends.
+
+Alternative considered: implement automatic interception or mandatory writes whenever an agent encounters uncertainty. The application cannot reliably infer those semantic events from arbitrary model turns, so explicit instructions are the smallest dependable mechanism.
+
+### Keep memory entries append-oriented and concise
+
+Agents will be told to append problems, missing information, assumptions, fixes, and conclusions to the matching assistant context. Existing `write_context` behavior already appends by default, which preserves earlier observations and avoids introducing a structured migration.
+
+Alternative considered: define mandatory headings or a machine-readable memory schema. That would add formatting and compatibility obligations without being necessary for the requested agent handoff behavior.
+
+### Keep user-facing summary content separate
+
+Assistant context remains internal meeting memory; the generated summary remains the user-facing artifact. Assumptions and missing evidence can inform explicit uncertainty in the summary, but diagnostic notes and repair history belong in assistant context.
+
+## Risks / Trade-offs
+
+- [Repeated agents may append duplicate observations] → Instruct agents to read existing context first and keep entries concise.
+- [Assistant context can grow over time] → Preserve existing ranged and tail reads; no new retention mechanism is introduced.
+- [Configured custom summary prompts omit the new built-in guidance] → Preserve the documented replacement semantics and leave responsibility with the custom prompt author.

openspec/changes/archive/2026-07-17-use-assistant-context-as-meeting-memory/proposal.md

@@ -0,0 +1,27 @@
+## Why
+
+The automatic summarizer and interactive agent window can encounter uncertainty, missing information, and repair conclusions that are useful to later work on the same meeting. Those observations currently depend on the active agent turn instead of being consistently preserved in the meeting's assistant context.
+
+## What Changes
+
+- Treat each assistant context file as meeting-specific memory shared by agents working on that meeting.
+- Guide the automatic summarizer to record unexpected problems, missing information, and assumptions in assistant context.
+- Guide the interactive agent window to consult assistant context when repairing a meeting or summary.
+- Guide the interactive agent window to append its fixes and conclusions to assistant context for future work on that meeting.
+
+## Capabilities
+
+### New Capabilities
+
+None.
+
+### Modified Capabilities
+
+- `meeting-summary`: Define the automatic summarizer's responsibility to persist uncertainty and problems in meeting-specific assistant context.
+- `meeting-session`: Define how the interactive agent window uses and updates assistant context during meeting and summary repairs.
+
+## Impact
+
+- Summary-agent default instructions and their behavior tests.
+- Interactive agent-window instructions and their behavior tests.
+- Agent documentation describing assistant context usage.

openspec/changes/archive/2026-07-17-use-assistant-context-as-meeting-memory/specs/meeting-session/spec.md

@@ -0,0 +1,14 @@
+## ADDED Requirements
+
+### Requirement: Interactive agent uses assistant context as meeting memory
+The interactive agent window instructions SHALL identify each assistant context file as meeting-specific memory.
+
+When the user asks the interactive agent to fix or investigate a meeting or summary, the instructions SHALL direct the agent to read the matching assistant context for clues about problems, missing information, assumptions, prior fixes, and conclusions.
+
+After repairing a meeting or summary, the instructions SHALL direct the agent to append a concise record of its fixes and conclusions to the matching assistant context.
+
+#### Scenario: Interactive agent repairs a meeting artifact
+- **GIVEN** a meeting has an assistant context file
+- **WHEN** the user asks the interactive agent to fix that meeting or its summary
+- **THEN** the agent instructions direct it to inspect the matching assistant context for relevant meeting-specific memory
+- **AND** direct it to append its fixes and conclusions to that assistant context

openspec/changes/archive/2026-07-17-use-assistant-context-as-meeting-memory/specs/meeting-summary/spec.md

@@ -0,0 +1,12 @@
+## ADDED Requirements
+
+### Requirement: Summary agent preserves meeting-specific working memory
+When Meeting Assistant uses the built-in summary-agent instructions, those instructions SHALL identify assistant context as persistent meeting-specific memory.
+
+The built-in instructions SHALL direct the summary agent to append unexpected problems, missing information, and assumptions encountered while summarizing to assistant context.
+
+#### Scenario: Summarizer encounters uncertainty
+- **GIVEN** the built-in summary-agent instructions are in use
+- **WHEN** the summary agent encounters an unexpected problem, cannot find needed information, or must make an assumption
+- **THEN** its instructions direct it to append a concise record to the meeting's assistant context
+- **AND** later agents can discover that record when working on the same meeting

openspec/changes/archive/2026-07-17-use-assistant-context-as-meeting-memory/tasks.md

@@ -0,0 +1,14 @@
+## 1. Automatic Summary Agent
+
+- [x] 1.1 Add a behavior test that requires the built-in summary instructions to treat assistant context as meeting-specific memory and record problems, missing information, and assumptions.
+- [x] 1.2 Update the built-in summary-agent guidance to satisfy the memory behavior.
+
+## 2. Interactive Agent Window
+
+- [x] 2.1 Add a behavior test that requires the interactive instructions to inspect assistant context during meeting or summary repair and record fixes and conclusions.
+- [x] 2.2 Update the interactive agent-window guidance to satisfy the memory behavior.
+
+## 3. Documentation and Validation
+
+- [x] 3.1 Document assistant context as shared meeting-specific agent memory.
+- [x] 3.2 Run focused behavior tests, the full test suite, and strict OpenSpec validation.

openspec/changes/archive/2026-07-27-handle-responses-event-streams/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-07-27

openspec/changes/archive/2026-07-27-handle-responses-event-streams/design.md

@@ -0,0 +1,40 @@
+## Context
+
+`LiteLlmResponsesChatClient` exposes a non-streaming `IChatClient` interface and currently buffers every successful `/v1/responses` body before parsing it as one JSON document. The deployed LiteLLM `chatgpt/gpt-5.5` route instead returns Responses Server-Sent Events. Microsoft.Extensions.AI.OpenAI already provides a Responses streaming adapter that maps the OpenAI SDK's typed SSE updates into `ChatResponseUpdate` values, including text, reasoning, function calls, response metadata, and usage.
+
+That adapter uses `FunctionCallContent.CreateFromParsedArguments`, which records argument-mapping failures on the function call instead of throwing them from the response parser. The default function invoker does not itself prevent invocation when that property is populated, so Meeting Assistant must turn the recorded parse failure into a matching function result before calling the tool.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- Preserve the existing non-streaming `IChatClient` contract while selecting the supported Responses streaming or non-streaming path through configuration.
+- Delegate SSE framing, event deserialization, streamed function-call assembly, response metadata, and usage mapping to the OpenAI SDK and Microsoft.Extensions.AI.OpenAI adapter.
+- Preserve the original encoded function arguments when forwarding conversation history.
+- Return a safe, structured invalid-arguments result for malformed argument JSON without invoking the requested tool.
+- Apply the guarded invocation behavior to both summary and workflow-editor agent pipelines that use this Responses client.
+
+**Non-Goals:**
+
+- Expose token-by-token upstream streaming to the UI.
+- Replace Microsoft.Extensions.AI function invocation or implement general JSON Schema validation.
+- Recover from an incomplete or malformed Responses event stream that has no usable completed output.
+
+## Decisions
+
+1. Add `Agent:UseStreaming`, defaulting to `true`, and send summary requests through the matching OpenAI SDK method. The streaming path uses `ResponsesClient.CreateResponseStreamingAsync` and collects the Microsoft.Extensions.AI.OpenAI typed updates into one `ChatResponse`; the non-streaming path uses `ResponsesClient.CreateResponseAsync` and its supported `AsChatResponse` adapter.
+
+2. Keep the existing JSON payload builder because it owns Meeting Assistant-specific compaction input, tool serialization, reasoning settings, retry diagnostics, and initiator behavior. Deserialize that payload into the OpenAI SDK's `CreateResponseOptions`, set its streaming flag from configuration, and let the selected SDK method own the HTTP response protocol.
+
+   The SDK deserializes `ResponseItem` values by their `type` discriminator. Message items must therefore include `"type": "message"` before the JSON payload is converted to `CreateResponseOptions`; otherwise the SDK reserializes them as `"type": "unknown"` and the provider rejects the request.
+
+3. Rely on the framework adapter's `FunctionCallContent.CreateFromParsedArguments` mapping for function-call argument decoding and raw response preservation. A shared function-invocation callback checks the recorded parse exception before invocation. For invalid JSON it returns a structured `invalid_tool_arguments` value that the framework associates with the original call ID; otherwise it delegates to the actual function.
+
+4. Configure both agent pipelines with the shared guarded invoker. This avoids duplicating the safety decision and prevents zero-argument tools from accidentally running when malformed JSON would otherwise map to an empty argument set.
+
+## Risks / Trade-offs
+
+- **[Provider event variants]** A provider could emit events outside the OpenAI Responses schema. → Use the maintained OpenAI SDK parser and fail diagnostically for genuinely incompatible streams instead of maintaining local event variants.
+- **[Buffered result]** The summary pipeline does not expose token-by-token updates to its caller. → Collect the framework updates only at the existing non-streaming boundary; the HTTP response itself remains streamed and incrementally parsed.
+- **[Experimental API]** The OpenAI Responses adapter is marked experimental in the currently referenced package. → Keep it behind `LiteLlmResponsesChatClient`, which isolates future package API changes from the rest of Meeting Assistant.
+- **[Error disclosure]** Raw parser exceptions may contain implementation details. → Return a stable error code and concise validation message rather than exception text or the malformed arguments.

openspec/changes/archive/2026-07-27-handle-responses-event-streams/proposal.md

@@ -0,0 +1,26 @@
+## Why
+
+The configured LiteLLM Responses endpoint can return successful responses as Server-Sent Events even when the request sets `stream: false`. Meeting Assistant currently treats every successful body as one JSON document, and it also lets malformed function-call argument JSON escape as a fatal parse exception, so either condition can abort an otherwise recoverable summary run.
+
+## What Changes
+
+- Consume the configured LiteLLM Responses endpoint through the supported OpenAI Responses streaming transport and Agent Framework adapter.
+- Assemble completed response output items and usage metadata from Responses SSE events before returning them through the existing non-streaming chat-client interface.
+- Add an agent setting that selects streaming or non-streaming Responses transport, with streaming enabled by default.
+- Preserve valid Responses item discriminators when translating agent messages through the OpenAI SDK request model.
+- Treat malformed function-call arguments as invalid tool input that is returned to the agent for correction without invoking the tool or terminating the summary run.
+- Add behavior tests for streamed text, streamed function calls, and invalid function-call arguments.
+
+## Capabilities
+
+### New Capabilities
+
+- None.
+
+### Modified Capabilities
+
+- `meeting-summary`: Make the existing Responses-based summary pipeline interoperable with SSE responses and resilient to malformed tool-call input.
+
+## Impact
+
+The change affects agent configuration, the custom LiteLLM Responses chat client, its summary-agent integration, and focused tests. It does not change the public HTTP API.

openspec/changes/archive/2026-07-27-handle-responses-event-streams/specs/meeting-summary/spec.md

@@ -0,0 +1,36 @@
+## ADDED Requirements
+
+### Requirement: Summary agents tolerate Responses event streams and malformed tool arguments
+Meeting Assistant SHALL consume successful summary-agent Responses results through the supported OpenAI Responses and Agent Framework Server-Sent Events adapter.
+
+When a Responses event stream delivers completed output items separately from the final response metadata, Meeting Assistant SHALL assemble those output items into one agent response while preserving final response metadata and usage.
+
+Meeting Assistant SHALL provide an agent setting that selects streaming or non-streaming Responses transport. Streaming SHALL be enabled by default. When streaming is disabled, Meeting Assistant SHALL use the supported non-streaming OpenAI Responses client and adapter.
+
+When a returned function call contains arguments that are not a valid JSON object, Meeting Assistant SHALL NOT invoke the requested function and SHALL return an invalid-tool-arguments result associated with the original call ID to the agent so it can correct the call.
+
+When Meeting Assistant translates chat messages into a Responses request, every message input item SHALL retain the `message` item discriminator required by the OpenAI SDK and Responses API.
+
+#### Scenario: Streamed text response is assembled
+- **WHEN** the configured Responses endpoint returns completed message output in Server-Sent Events followed by final response metadata
+- **THEN** the summary agent receives the completed message text, response metadata, and usage without a JSON document parse failure
+
+#### Scenario: Streamed function call is assembled
+- **WHEN** the configured Responses endpoint returns a completed function-call output item in Server-Sent Events
+- **THEN** the summary agent receives the function call with its call ID, function name, and parsed arguments
+
+#### Scenario: Streaming transport can be disabled
+- **WHEN** `MeetingAssistant:Agent:UseStreaming` is `false`
+- **THEN** the summary agent requests a non-streaming Responses result
+- **AND** converts the response through the supported OpenAI Responses adapter
+
+#### Scenario: Chat message input remains a Responses message
+- **WHEN** the summary agent sends a user or assistant chat message through the Responses client
+- **THEN** the outbound Responses input item has type `message`
+- **AND** the request does not contain an `unknown` input item type
+
+#### Scenario: Malformed function arguments are returned to the agent
+- **WHEN** the model returns a function call whose arguments are not a valid JSON object
+- **THEN** Meeting Assistant does not invoke the requested function
+- **AND** sends a function result with an invalid-tool-arguments error for the original call ID back to the agent
+- **AND** allows the agent loop to continue

openspec/changes/archive/2026-07-27-handle-responses-event-streams/tasks.md

@@ -0,0 +1,24 @@
+## 1. Responses SSE compatibility
+
+- [x] 1.1 Add a failing client behavior test for a streamed text response with final metadata and usage.
+- [x] 1.2 Add failing configuration and client behavior tests for selecting non-streaming Responses transport.
+- [x] 1.3 Route Responses requests through the Agent Framework/OpenAI SDK streaming or non-streaming adapter according to configuration.
+- [x] 1.4 Add behavior coverage for streamed function-call output.
+
+## 2. Invalid tool-argument recovery
+
+- [x] 2.1 Add a failing agent-loop behavior test proving malformed function-call JSON does not invoke the tool and is returned to the agent.
+- [x] 2.2 Preserve argument parse failures on function-call content and add the shared guarded function invoker.
+- [x] 2.3 Apply guarded function invocation to the summary and workflow-editor agent pipelines.
+
+## 3. Verification
+
+- [x] 3.1 Refactor the touched response and invocation paths for DRYness, SOLID boundaries, and simplicity while preserving behavior.
+- [x] 3.2 Run focused tests, the full solution tests, and strict OpenSpec validation.
+- [x] 3.3 Verify the client behavior against the deployed LiteLLM Responses endpoint and restart Meeting Assistant only after confirming it is idle.
+
+## 4. Responses message-item compatibility
+
+- [x] 4.1 Add a failing client behavior test proving an outbound chat message retains the `message` discriminator through SDK serialization.
+- [x] 4.2 Emit the Responses `message` discriminator for chat message input items.
+- [x] 4.3 Run focused and full tests, validate OpenSpec strictly, restart while idle, and retry the failed summary through the local API.

openspec/specs/meeting-session/spec.md

@@ -362,3 +362,16 @@ Meeting Assistant SHALL provide a diagnostic endpoint that opens the workflow ru
 - **GIVEN** the rules editor chat window content fits without scrolling or is already near the bottom
 - **WHEN** a new user or assistant message is appended
 - **THEN** the conversation scrolls to the bottom of the newly rendered message content
+
+### Requirement: Interactive agent uses assistant context as meeting memory
+The interactive agent window instructions SHALL identify each assistant context file as meeting-specific memory.
+
+When the user asks the interactive agent to fix or investigate a meeting or summary, the instructions SHALL direct the agent to read the matching assistant context for clues about problems, missing information, assumptions, prior fixes, and conclusions.
+
+After repairing a meeting or summary, the instructions SHALL direct the agent to append a concise record of its fixes and conclusions to the matching assistant context.
+
+#### Scenario: Interactive agent repairs a meeting artifact
+- **GIVEN** a meeting has an assistant context file
+- **WHEN** the user asks the interactive agent to fix that meeting or its summary
+- **THEN** the agent instructions direct it to inspect the matching assistant context for relevant meeting-specific memory
+- **AND** direct it to append its fixes and conclusions to that assistant context

openspec/specs/meeting-summary/spec.md

@@ -140,3 +140,49 @@ The summary-agent instructions SHALL tell the agent to keep the one-line summary
 - **THEN** Meeting Assistant refuses the write
 - **AND** does not mark the summary as written
 
+### Requirement: Summary agent preserves meeting-specific working memory
+When Meeting Assistant uses the built-in summary-agent instructions, those instructions SHALL identify assistant context as persistent meeting-specific memory.
+
+The built-in instructions SHALL direct the summary agent to append unexpected problems, missing information, and assumptions encountered while summarizing to assistant context.
+
+#### Scenario: Summarizer encounters uncertainty
+- **GIVEN** the built-in summary-agent instructions are in use
+- **WHEN** the summary agent encounters an unexpected problem, cannot find needed information, or must make an assumption
+- **THEN** its instructions direct it to append a concise record to the meeting's assistant context
+- **AND** later agents can discover that record when working on the same meeting
+
+### Requirement: Summary agents tolerate Responses event streams and malformed tool arguments
+Meeting Assistant SHALL consume successful summary-agent Responses results through the supported OpenAI Responses and Agent Framework Server-Sent Events adapter.
+
+When a Responses event stream delivers completed output items separately from the final response metadata, Meeting Assistant SHALL assemble those output items into one agent response while preserving final response metadata and usage.
+
+Meeting Assistant SHALL provide an agent setting that selects streaming or non-streaming Responses transport. Streaming SHALL be enabled by default. When streaming is disabled, Meeting Assistant SHALL use the supported non-streaming OpenAI Responses client and adapter.
+
+When a returned function call contains arguments that are not a valid JSON object, Meeting Assistant SHALL NOT invoke the requested function and SHALL return an invalid-tool-arguments result associated with the original call ID to the agent so it can correct the call.
+
+When Meeting Assistant translates chat messages into a Responses request, every message input item SHALL retain the `message` item discriminator required by the OpenAI SDK and Responses API.
+
+#### Scenario: Streamed text response is assembled
+- **WHEN** the configured Responses endpoint returns completed message output in Server-Sent Events followed by final response metadata
+- **THEN** the summary agent receives the completed message text, response metadata, and usage without a JSON document parse failure
+
+#### Scenario: Streamed function call is assembled
+- **WHEN** the configured Responses endpoint returns a completed function-call output item in Server-Sent Events
+- **THEN** the summary agent receives the function call with its call ID, function name, and parsed arguments
+
+#### Scenario: Streaming transport can be disabled
+- **WHEN** `MeetingAssistant:Agent:UseStreaming` is `false`
+- **THEN** the summary agent requests a non-streaming Responses result
+- **AND** converts the response through the supported OpenAI Responses adapter
+
+#### Scenario: Chat message input remains a Responses message
+- **WHEN** the summary agent sends a user or assistant chat message through the Responses client
+- **THEN** the outbound Responses input item has type `message`
+- **AND** the request does not contain an `unknown` input item type
+
+#### Scenario: Malformed function arguments are returned to the agent
+- **WHEN** the model returns a function call whose arguments are not a valid JSON object
+- **THEN** Meeting Assistant does not invoke the requested function
+- **AND** sends a function result with an invalid-tool-arguments error for the original call ID back to the agent
+- **AND** allows the agent loop to continue
+