testes

Author: KSemenenko

.github/workflows/ci.yml

@@ -46,24 +46,3 @@ jobs:
 
       - name: Smoke tests (Codex CLI discover + invoke)
         run: dotnet test --solution ManagedCode.CodexSharpSDK.slnx -c Release --no-build -- --treenode-filter "/*/*/*/CodexCli_Smoke_*"
-
-  aot-smoke:
-    name: NativeAOT Smoke
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: ${{ env.DOTNET_VERSION }}
-
-      - name: Publish AOT smoke app
-        run: |
-          dotnet publish tests/AotSmoke/ManagedCode.CodexSharpSDK.AotSmoke.csproj \
-            -c Release \
-            -r linux-x64 \
-            -p:PublishAot=true \
-            --self-contained true

AGENTS.md

@@ -69,7 +69,6 @@ If no new rule is detected -> do not update the file.
 - format: `dotnet format ManagedCode.CodexSharpSDK.slnx`
 - analyze: `dotnet build ManagedCode.CodexSharpSDK.slnx -c Release -warnaserror /p:TreatWarningsAsErrors=true`
 - coverage: `dotnet test --solution ManagedCode.CodexSharpSDK.slnx -c Release -- --coverage --coverage-output-format cobertura --coverage-output coverage.cobertura.xml`
-- aot-smoke: `dotnet publish tests/AotSmoke/ManagedCode.CodexSharpSDK.AotSmoke.csproj -c Release -r osx-arm64 /p:PublishAot=true`
 - For Codex CLI metadata checks (for example model list/default), always use the installed `codex` CLI directly first; do not use `cargo`/submodule helper binaries unless explicitly requested.
 
 ### Task Delivery (ALL TASKS)
@@ -88,15 +87,15 @@ If no new rule is detected -> do not update the file.
   - `docs/Architecture/Overview.md` when module boundaries or interactions change
 - Implement code and tests together.
 - When asked to fix review findings, close every confirmed finding in the same pass; do not leave partial fixes.
-- Do not keep or add public sample projects; repository focus is SDK + tests (including AOT tests) only.
+- Do not keep or add public sample projects; repository focus is SDK + tests only.
 - Upstream sync automation must track real `openai/codex` CLI changes (flags/models/features), not TypeScript SDK surface diffs, and open actionable repository issues for required SDK follow-up.
 - Automatically opened upstream sync issues must include change summary/checklist and assign Copilot by default.
 - Run verification in this order:
   - focused tests for changed behavior
   - full solution tests
   - format
   - final build
-- If changes impact trimming/AOT safety, run `aot-smoke`.
+- If changes impact trimming/AOT safety, validate via AOT-safe API design (for example `JsonTypeInfo<T>` overloads and annotations) and existing test/build gates; do not introduce a dedicated AOT smoke test project unless explicitly requested.
 
 ### Documentation (ALL TASKS)
 

CodexSharpSDK.Tests/Unit/CodexCliMetadataReaderTests.cs

@@ -157,7 +157,7 @@ public async Task ParseModelsCache_ParsesListedAndHiddenModels()
         using var document = JsonDocument.Parse(json);
         var parsed = CodexCliMetadataReader.ParseModelsCache(document.RootElement);
 
-        await Assert.That(parsed).HasCount(2);
+        await Assert.That(parsed).Count().IsEqualTo(2);
         await Assert.That(parsed[0].Slug).IsEqualTo("gpt-5.3-codex");
         await Assert.That(parsed[0].IsListed).IsTrue();
         await Assert.That(parsed[0].IsApiSupported).IsTrue();

CodexSharpSDK.Tests/Unit/CodexClientTests.cs

@@ -45,7 +45,7 @@ public async Task StartThread_CanBeCalledConcurrently()
             Enumerable.Range(0, 64)
                 .Select(_ => Task.Run(() => client.StartThread())));
 
-        await Assert.That(createdThreads).HasCount(64);
+        await Assert.That(createdThreads).Count().IsEqualTo(64);
         await Assert.That(createdThreads.All(thread => thread.Id is null)).IsTrue();
         await Assert.That(client.State).IsEqualTo(CodexClientState.Connected);
     }

CodexSharpSDK.Tests/Unit/CodexThreadTests.cs

@@ -167,7 +167,7 @@ public async Task RunAsync_HonorsCancellationToken()
             CancellationToken = cancellationSource.Token,
         });
 
-        var exception = await Assert.That(action).ThrowsException();
+        var exception = await Assert.That(action!).ThrowsException();
         await Assert.That(exception).IsTypeOf<OperationCanceledException>();
     }
 
@@ -178,7 +178,7 @@ public async Task RunAsync_GenericStructuredOutput_ThrowsWhenSchemaMissing()
         var thread = new CodexThread(exec, new CodexOptions(), new ThreadOptions());
 
         var action = async () => await thread.RunAsync<StatusResponse>("typed output without schema");
-        var exception = await Assert.That(action).ThrowsException();
+        var exception = await Assert.That(action!).ThrowsException();
 
         await Assert.That(exception).IsTypeOf<InvalidOperationException>();
         await Assert.That(exception!.Message).Contains(nameof(TurnOptions.OutputSchema));
@@ -195,7 +195,7 @@ public async Task RunAsync_GenericStructuredOutput_WithSchemaShortcut_ThrowsWhen
             null!,
             IntegrationOutputJsonContext.Default.StatusResponse);
 
-        var exception = await Assert.That(action).ThrowsException();
+        var exception = await Assert.That(action!).ThrowsException();
         await Assert.That(exception).IsTypeOf<ArgumentNullException>();
         await Assert.That(((ArgumentNullException)exception!).ParamName).IsEqualTo("outputSchema");
     }

CodexSharpSDK.Tests/Unit/ThreadEventParserTests.cs

@@ -22,7 +22,7 @@ public async Task Parse_RecognizesAllTopLevelEventKinds()
 
         var parsed = events.Select(ThreadEventParser.Parse).ToList();
 
-        await Assert.That(parsed).HasCount(8);
+        await Assert.That(parsed).Count().IsEqualTo(8);
         await Assert.That(parsed[0]).IsTypeOf<ThreadStartedEvent>();
         await Assert.That(parsed[1]).IsTypeOf<TurnStartedEvent>();
         await Assert.That(parsed[2]).IsTypeOf<TurnCompletedEvent>();
@@ -55,7 +55,7 @@ public async Task Parse_RecognizesAllItemKinds()
             .Select(itemCompleted => itemCompleted.Item)
             .ToList();
 
-        await Assert.That(parsedItems).HasCount(9);
+        await Assert.That(parsedItems).Count().IsEqualTo(9);
         await Assert.That(parsedItems[0]).IsTypeOf<AgentMessageItem>();
         await Assert.That(parsedItems[1]).IsTypeOf<ReasoningItem>();
         await Assert.That(parsedItems[2]).IsTypeOf<CommandExecutionItem>();

CodexSharpSDK/Client/CodexThread.cs

@@ -87,7 +87,7 @@ public async Task<RunResult<TResponse>> RunAsync<TResponse>(string input, TurnOp
         ArgumentNullException.ThrowIfNull(input);
         var runOptions = EnsureTypedRunOptions(turnOptions);
         var normalizedInput = new NormalizedInput(input, []);
-        return await RunTypedInternalAsync<TResponse>(normalizedInput, runOptions, jsonTypeInfo: null).ConfigureAwait(false);
+        return await RunTypedInternalWithReflectionAsync<TResponse>(normalizedInput, runOptions).ConfigureAwait(false);
     }
 
     public async Task<RunResult<TResponse>> RunAsync<TResponse>(
@@ -110,7 +110,7 @@ public async Task<RunResult<TResponse>> RunAsync<TResponse>(IReadOnlyList<UserIn
         ThrowIfDisposed();
         var runOptions = EnsureTypedRunOptions(turnOptions);
         var normalizedInput = NormalizeInput(input);
-        return await RunTypedInternalAsync<TResponse>(normalizedInput, runOptions, jsonTypeInfo: null).ConfigureAwait(false);
+        return await RunTypedInternalWithReflectionAsync<TResponse>(normalizedInput, runOptions).ConfigureAwait(false);
     }
 
     public async Task<RunResult<TResponse>> RunAsync<TResponse>(
@@ -137,7 +137,7 @@ public Task<RunResult<TResponse>> RunAsync<TResponse>(
         ArgumentNullException.ThrowIfNull(input);
         var normalizedInput = new NormalizedInput(input, []);
         var runOptions = CreateTypedTurnOptions(outputSchema, cancellationToken);
-        return RunTypedInternalAsync<TResponse>(normalizedInput, runOptions, jsonTypeInfo: null);
+        return RunTypedInternalWithReflectionAsync<TResponse>(normalizedInput, runOptions);
     }
 
     public Task<RunResult<TResponse>> RunAsync<TResponse>(
@@ -164,7 +164,7 @@ public Task<RunResult<TResponse>> RunAsync<TResponse>(
         ThrowIfDisposed();
         var normalizedInput = NormalizeInput(input);
         var runOptions = CreateTypedTurnOptions(outputSchema, cancellationToken);
-        return RunTypedInternalAsync<TResponse>(normalizedInput, runOptions, jsonTypeInfo: null);
+        return RunTypedInternalWithReflectionAsync<TResponse>(normalizedInput, runOptions);
     }
 
     public Task<RunResult<TResponse>> RunAsync<TResponse>(
@@ -384,7 +384,7 @@ private static TurnOptions CreateTypedTurnOptions(
     private async Task<RunResult<TResponse>> RunTypedInternalAsync<TResponse>(
         NormalizedInput normalizedInput,
         TurnOptions turnOptions,
-        JsonTypeInfo<TResponse>? jsonTypeInfo)
+        JsonTypeInfo<TResponse> jsonTypeInfo)
     {
         var runResult = await RunInternalAsync(normalizedInput, turnOptions).ConfigureAwait(false);
         var typedResponse = DeserializeTypedResponse(runResult.FinalResponse, jsonTypeInfo);
@@ -396,21 +396,56 @@ private async Task<RunResult<TResponse>> RunTypedInternalAsync<TResponse>(
             typedResponse);
     }
 
+    [RequiresDynamicCode(AotUnsafeTypedRunMessage)]
+    [RequiresUnreferencedCode(AotUnsafeTypedRunMessage)]
+    private async Task<RunResult<TResponse>> RunTypedInternalWithReflectionAsync<TResponse>(
+        NormalizedInput normalizedInput,
+        TurnOptions turnOptions)
+    {
+        var runResult = await RunInternalAsync(normalizedInput, turnOptions).ConfigureAwait(false);
+        var typedResponse = DeserializeTypedResponseWithReflection<TResponse>(runResult.FinalResponse);
+
+        return new RunResult<TResponse>(
+            runResult.Items,
+            runResult.FinalResponse,
+            runResult.Usage,
+            typedResponse);
+    }
+
     private static TResponse DeserializeTypedResponse<TResponse>(
         string payload,
-        JsonTypeInfo<TResponse>? jsonTypeInfo)
+        JsonTypeInfo<TResponse> jsonTypeInfo)
+    {
+        ArgumentNullException.ThrowIfNull(jsonTypeInfo);
+
+        try
+        {
+            var response = JsonSerializer.Deserialize(payload, jsonTypeInfo);
+            return response
+                ?? throw new InvalidOperationException(
+                    $"{EmptyTypedRunResponseMessagePrefix} '{typeof(TResponse).Name}'.");
+        }
+        catch (JsonException exception)
+        {
+            throw new InvalidOperationException(
+                $"{TypedRunDeserializeFailedMessagePrefix} '{typeof(TResponse).Name}'.",
+                exception);
+        }
+    }
+
+    [RequiresDynamicCode(AotUnsafeTypedRunMessage)]
+    [RequiresUnreferencedCode(AotUnsafeTypedRunMessage)]
+    private static TResponse DeserializeTypedResponseWithReflection<TResponse>(string payload)
     {
         try
         {
-            var response = jsonTypeInfo is null
-                ? JsonSerializer.Deserialize<TResponse>(payload)
-                : JsonSerializer.Deserialize(payload, jsonTypeInfo);
+            var response = JsonSerializer.Deserialize<TResponse>(payload);
             return response
                 ?? throw new InvalidOperationException(
                     $"{EmptyTypedRunResponseMessagePrefix} '{typeof(TResponse).Name}'.");
         }
         catch (InvalidOperationException exception)
-            when (jsonTypeInfo is null && IsReflectionDisabledSerializationError(exception))
+            when (IsReflectionDisabledSerializationError(exception))
         {
             throw new InvalidOperationException(TypedRunRequiresTypeInfoMessage, exception);
         }

Directory.Packages.props

@@ -2,12 +2,11 @@
   <PropertyGroup>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
-
   <ItemGroup>
-    <PackageVersion Include="DotNet.ReproducibleBuilds" Version="1.2.25" />
-    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
-    <PackageVersion Include="TUnit" Version="1.0.0" />
-    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
+    <PackageVersion Include="DotNet.ReproducibleBuilds" Version="2.0.2" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="10.0.103" />
+    <PackageVersion Include="TUnit" Version="1.18.21" />
+    <PackageVersion Include="coverlet.collector" Version="8.0.0" />
   </ItemGroup>
-</Project>
+</Project>

README.md

@@ -258,10 +258,3 @@ await resumed.RunAsync("Continue from previous plan");
 dotnet build ManagedCode.CodexSharpSDK.slnx -c Release -warnaserror
 dotnet test --solution ManagedCode.CodexSharpSDK.slnx -c Release
 ```
-
-## AOT Smoke Check
-
-```bash
-dotnet publish tests/AotSmoke/ManagedCode.CodexSharpSDK.AotSmoke.csproj \
-  -c Release -r linux-x64 -p:PublishAot=true --self-contained true
-```

docs/Development/setup.md

@@ -31,13 +31,7 @@ dotnet format ManagedCode.CodexSharpSDK.slnx
 Focused run (TUnit/MTP):
 
 ```bash
-dotnet test --project tests/CodexSharpSDK.Tests.csproj -c Release -- --treenode-filter "/*/*/ThreadEventParserTests/*"
-```
-
-## AOT smoke check
-
-```bash
-dotnet publish tests/AotSmoke/ManagedCode.CodexSharpSDK.AotSmoke.csproj -c Release -r osx-arm64 /p:PublishAot=true
+dotnet test --project CodexSharpSDK.Tests/CodexSharpSDK.Tests.csproj -c Release -- --treenode-filter "/*/*/ThreadEventParserTests/*"
 ```
 
 ## Packaging check