Merge remote-tracking branch 'origin/main' into edburns/80-java-monorepo-add-phase-01

Author: edburns

dotnet/src/Generated/Rpc.cs

@@ -30,6 +30,8 @@ internal sealed class StringSyntaxAttribute : Attribute
 {
     public const string Uri = nameof(Uri);
 
+    public const string Regex = nameof(Regex);
+
     public StringSyntaxAttribute(string syntax)
     {
         Syntax = syntax;

dotnet/src/Generated/SessionEvents.cs

@@ -1427,7 +1427,7 @@ public async Task LogAsync(string message, SessionLogLevel? level = null, bool?
         ArgumentNullException.ThrowIfNull(message);
         ThrowIfDisposed();
 
-        await Rpc.LogAsync(message, level, ephemeral, url, cancellationToken);
+        await Rpc.LogAsync(message, level, ephemeral: ephemeral, url: url, cancellationToken: cancellationToken);
     }
 
     /// <summary>

dotnet/src/Polyfills/CodeAnalysisAttributes.cs

@@ -2795,9 +2795,9 @@ public class PingResponse
     /// </summary>
     public string Message { get; set; } = string.Empty;
     /// <summary>
-    /// Server timestamp when the ping was processed.
+    /// ISO 8601 timestamp when the ping was processed.
     /// </summary>
-    public long Timestamp { get; set; }
+    public DateTimeOffset Timestamp { get; set; }
     /// <summary>
     /// Protocol version supported by the server.
     /// </summary>

dotnet/src/Session.cs

@@ -25,7 +25,7 @@ public async Task Should_Start_And_Connect_To_Server(bool useStdio)
 
             var pong = await client.PingAsync("test message");
             Assert.Equal("pong: test message", pong.Message);
-            Assert.True(pong.Timestamp >= 0);
+            Assert.NotEqual(default, pong.Timestamp);
 
             await client.StopAsync();
             Assert.Equal(ConnectionState.Disconnected, client.State);

dotnet/src/Types.cs

@@ -147,8 +147,8 @@ await session.SendAsync(new MessageOptions
             Prompt = "What is 9+9? Reply with just the number.",
         });
 
-        var pendingEvent = await pendingMessagesModified;
         var answer = await TestHelper.GetFinalAssistantMessageAsync(session);
+        var pendingEvent = await pendingMessagesModified;
 
         Assert.NotNull(pendingEvent);
         Assert.Contains("18", answer?.Data.Content ?? string.Empty);

dotnet/test/E2E/ClientE2ETests.cs

@@ -322,7 +322,12 @@ public async Task Should_Allow_PostToolUse_To_Return_ModifiedResult()
 
                     return Task.FromResult<PostToolUseHookOutput?>(new PostToolUseHookOutput
                     {
-                        ModifiedResult = "modified by post hook",
+                        ModifiedResult = new ToolResultObject
+                        {
+                            TextResultForLlm = "modified by post hook",
+                            ResultType = "success",
+                            ToolTelemetry = new Dictionary<string, object>(),
+                        },
                         SuppressOutput = false,
                     });
                 },

dotnet/test/E2E/EventFidelityE2ETests.cs

@@ -103,9 +103,10 @@ public async Task Should_Invoke_Auto_Mode_Switch_Handler_When_Rate_Limited()
             },
         });
 
+        const long expectedRetryAfter = 1;
         var requestedEventTask = GetNextEventOfTypeAllowingRateLimitAsync<AutoModeSwitchRequestedEvent>(
             session,
-            evt => evt.Data.ErrorCode == "user_weekly_rate_limited" && evt.Data.RetryAfterSeconds == 1,
+            evt => evt.Data.ErrorCode == "user_weekly_rate_limited" && evt.Data.RetryAfterSeconds == expectedRetryAfter,
             TimeSpan.FromSeconds(30),
             timeoutDescription: "auto_mode_switch.requested event");
         var completedEventTask = GetNextEventOfTypeAllowingRateLimitAsync<AutoModeSwitchCompletedEvent>(
@@ -137,7 +138,7 @@ public async Task Should_Invoke_Auto_Mode_Switch_Handler_When_Rate_Limited()
 
         var requestedEvent = await requestedEventTask;
         Assert.Equal(request.ErrorCode, requestedEvent.Data.ErrorCode);
-        Assert.Equal(request.RetryAfterSeconds, requestedEvent.Data.RetryAfterSeconds);
+        Assert.Equal(expectedRetryAfter, requestedEvent.Data.RetryAfterSeconds);
 
         var completedEvent = await completedEventTask;
         Assert.Equal(AutoModeSwitchResponse.Yes, completedEvent.Data.Response);

dotnet/test/E2E/HookLifecycleAndOutputE2ETests.cs

@@ -151,11 +151,11 @@ public async Task Usage_GetMetrics_On_Fresh_Session_Returns_Zero_Tokens()
         var metrics = await session.Rpc.Usage.GetMetricsAsync();
 
         // Fresh session = no LLM calls yet. Last-call counters and the user-request count
-        // must be zero, and SessionStartTime must be a positive epoch (set at create-time).
+        // must be zero, and SessionStartTime must be populated at create-time.
         Assert.Equal(0, metrics.LastCallInputTokens);
         Assert.Equal(0, metrics.LastCallOutputTokens);
         Assert.Equal(0, metrics.TotalUserRequests);
-        Assert.True(metrics.SessionStartTime > 0, "SessionStartTime should be a positive epoch.");
+        Assert.NotEqual(default, metrics.SessionStartTime);
     }
 
     [Fact]