Release 0.1.1 and sync Claude Code upstream reference

Author: KSemenenko

AGENTS.md

@@ -157,6 +157,7 @@ If no new rule is detected -> do not update the file.
 - Never add fake fallback calls/mocks in production paths; unsupported runtime cases must fail explicitly with actionable errors.
 - No magic literals: extract constants/enums/config values.
 - In SDK production code, do not inline string literals in implementation logic; promote them to named constants (paths, env vars, command names, switch/comparison tokens) for reviewability and consistency.
+- Outside constant declarations themselves, do not use inline string literals in C# code; every implementation/test string value must be routed through a named constant for consistency during review and refactoring.
 - Do not inline filesystem/path segment string literals in implementation logic; define named constants and reuse them.
 - Never override or silently mutate explicit user-provided Claude Code CLI settings (for example `web_search=disabled`); pass through user intent exactly.
 - Protocol and CLI string tokens are mandatory constants: never inline literals in parsing, mapping, or switch branches.
@@ -165,6 +166,7 @@ If no new rule is detected -> do not update the file.
 - Keep public API and naming aligned with package/namespace `ManagedCode.ClaudeCodeSharpSDK`.
 - Solution/workspace file naming must use `ManagedCode.ClaudeCodeSharpSDK` prefix for consistency with package identity.
 - Keep package/version metadata centralized in `Directory.Build.props`; avoid duplicating version structure or release metadata blocks in individual `.csproj` files unless a project-specific override is required.
+- Do not bump package/release version for PRs that only change tests or submodule-backed test/reference material and do not touch SDK production projects (`ClaudeCodeSharpSDK*` runtime code); merge/commit such changes without creating a new release version.
 - Never hardcode guessed Claude/Anthropic model names in tests, docs, or defaults; verify supported models and active default via Claude Code CLI first.
 - Before setting or changing any `Model` value, read available models and current default from the local `claude` CLI in the same environment/account and only then update code/tests/docs.
 - Model identifiers in code/tests must come from centralized constants or a shared resolver helper; do not inline model string literals repeatedly.

ClaudeCodeSharpSDK.Extensions.AI/Internal/ChatOptionsMapper.cs

@@ -7,6 +7,11 @@ namespace ManagedCode.ClaudeCodeSharpSDK.Extensions.AI.Internal;
 
 internal static class ChatOptionsMapper
 {
+    private const string InvalidValueMessagePrefix = "Invalid value for Claude chat option";
+    private const string Space = " ";
+    private const string MessageQuote = "'";
+    private const string MessageSuffix = ".";
+
     internal const string WorkingDirectoryKey = "claude:working_directory";
     internal const string PermissionModeKey = "claude:permission_mode";
     internal const string AllowedToolsKey = "claude:allowed_tools";
@@ -231,6 +236,6 @@ when decimal.TryParse(jsonString.GetString(), NumberStyles.Number, CultureInfo.I
 
     private static InvalidOperationException CreateInvalidValueException(string key)
     {
-        return new InvalidOperationException($"Invalid value for Claude chat option '{key}'.");
+        return new InvalidOperationException(string.Concat(InvalidValueMessagePrefix, Space, MessageQuote, key, MessageQuote, MessageSuffix));
     }
 }

ClaudeCodeSharpSDK.Extensions.AI/Properties/AssemblyInfo.cs

@@ -1,3 +1,8 @@
 using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("ManagedCode.ClaudeCodeSharpSDK.Tests")]
+[assembly: InternalsVisibleTo(AssemblyNames.TestsAssemblyName)]
+
+internal static class AssemblyNames
+{
+    internal const string TestsAssemblyName = "ManagedCode.ClaudeCodeSharpSDK.Tests";
+}

ClaudeCodeSharpSDK.Tests/Integration/ClaudeCliSmokeTests.cs

@@ -1,13 +1,12 @@
 using System.Diagnostics;
 using System.Text.Json;
 using ManagedCode.ClaudeCodeSharpSDK.Internal;
+using ManagedCode.ClaudeCodeSharpSDK.Tests.Shared;
 
 namespace ManagedCode.ClaudeCodeSharpSDK.Tests.Integration;
 
 public class ClaudeCliSmokeTests
 {
-    private const string SolutionFileName = "ManagedCode.ClaudeCodeSharpSDK.slnx";
-    private const string SandboxDirectoryName = ".sandbox";
     private const string SandboxPrefix = "ClaudeCliSmokeTests-";
     private const string HomeEnvironmentVariable = "HOME";
     private const string UserProfileEnvironmentVariable = "USERPROFILE";
@@ -17,6 +16,31 @@ public class ClaudeCliSmokeTests
     private const string ClaudeConfigDirEnvironmentVariable = "CLAUDE_CONFIG_DIR";
     private const string AnthropicApiKeyEnvironmentVariable = "ANTHROPIC_API_KEY";
     private const string AnthropicBaseUrlEnvironmentVariable = "ANTHROPIC_BASE_URL";
+    private const string VersionFlag = "--version";
+    private const string HelpFlag = "--help";
+    private const string PrintFlag = "-p";
+    private const string OutputFormatFlag = "--output-format";
+    private const string StreamJsonFormat = "stream-json";
+    private const string VerboseFlag = "--verbose";
+    private const string ReplyWithOkPrompt = "Reply with ok";
+    private const string ClaudeCodeFragment = "Claude Code";
+    private const string LoginGuidanceFragment = "Please run /login";
+    private const string ErrorJsonFragment = "\"is_error\":true";
+    private const string TypePropertyName = "type";
+    private const string SystemType = "system";
+    private const string ResultType = "result";
+    private const string ClaudeConfigDirectoryName = ".claude";
+    private const string ConfigDirectoryName = ".config";
+    private const string NewLine = "\n";
+    private const string CarriageReturn = "\r";
+    private const string PathRootedButMissingMessagePrefix = "Claude Code CLI path is rooted but missing:";
+    private const string FailedToResolveExecutablePathMessage = "Failed to resolve Claude Code CLI path.";
+    private const string CouldNotLocateRepositoryRootMessage = "Could not locate repository root from test execution directory.";
+    private const string StartProcessFailedMessagePrefix = "Failed to start Claude Code CLI at";
+    private const string Space = " ";
+    private const string MessageQuote = "'";
+    private const string MessageSuffix = ".";
+    private static readonly string[] StandardLineSeparators = [Environment.NewLine, NewLine, CarriageReturn];
 
     [Test]
     public async Task ClaudeCli_Smoke_FindExecutablePath_ResolvesExistingBinary()
@@ -28,21 +52,21 @@ public async Task ClaudeCli_Smoke_FindExecutablePath_ResolvesExistingBinary()
     [Test]
     public async Task ClaudeCli_Smoke_VersionCommand_ReturnsClaudeCodeVersion()
     {
-        var result = await RunClaudeAsync(ResolveExecutablePath(), null, "--version");
+        var result = await RunClaudeAsync(ResolveExecutablePath(), null, VersionFlag);
 
         await Assert.That(result.ExitCode).IsEqualTo(0);
         await Assert.That(string.Concat(result.StandardOutput, result.StandardError))
-            .Contains("Claude Code");
+            .Contains(ClaudeCodeFragment);
     }
 
     [Test]
     public async Task ClaudeCli_Smoke_HelpCommand_DescribesStreamJsonOutput()
     {
-        var result = await RunClaudeAsync(ResolveExecutablePath(), null, "--help");
+        var result = await RunClaudeAsync(ResolveExecutablePath(), null, HelpFlag);
 
         await Assert.That(result.ExitCode).IsEqualTo(0);
         await Assert.That(string.Concat(result.StandardOutput, result.StandardError))
-            .Contains("--output-format");
+            .Contains(OutputFormatFlag);
     }
 
     [Test]
@@ -55,24 +79,24 @@ public async Task ClaudeCli_Smoke_PrintModeWithoutAuth_EmitsInitAndLoginGuidance
             var result = await RunClaudeAsync(
                 ResolveExecutablePath(),
                 CreateUnauthenticatedEnvironmentOverrides(sandboxDirectory),
-                "-p",
-                "--output-format",
-                "stream-json",
-                "--verbose",
-                "Reply with ok");
+                PrintFlag,
+                OutputFormatFlag,
+                StreamJsonFormat,
+                VerboseFlag,
+                ReplyWithOkPrompt);
 
             var stdoutLines = result.StandardOutput
-                .Split([Environment.NewLine, "\n", "\r"], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+                .Split(StandardLineSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 
             await Assert.That(stdoutLines.Length).IsGreaterThanOrEqualTo(2);
-            await Assert.That(result.StandardOutput).Contains("Please run /login");
-            await Assert.That(result.StandardOutput).Contains("\"is_error\":true");
+            await Assert.That(result.StandardOutput).Contains(LoginGuidanceFragment);
+            await Assert.That(result.StandardOutput).Contains(ErrorJsonFragment);
 
             using var initDocument = JsonDocument.Parse(stdoutLines[0]);
             using var finalDocument = JsonDocument.Parse(stdoutLines[^1]);
 
-            await Assert.That(initDocument.RootElement.GetProperty("type").GetString()).IsEqualTo("system");
-            await Assert.That(finalDocument.RootElement.GetProperty("type").GetString()).IsEqualTo("result");
+            await Assert.That(initDocument.RootElement.GetProperty(TypePropertyName).GetString()).IsEqualTo(SystemType);
+            await Assert.That(finalDocument.RootElement.GetProperty(TypePropertyName).GetString()).IsEqualTo(ResultType);
         }
         finally
         {
@@ -90,37 +114,44 @@ private static string ResolveExecutablePath()
                 return resolvedPath;
             }
 
-            throw new InvalidOperationException($"Claude Code CLI path is rooted but missing: '{resolvedPath}'.");
+            throw new InvalidOperationException(
+                string.Concat(
+                    PathRootedButMissingMessagePrefix,
+                    Space,
+                    MessageQuote,
+                    resolvedPath,
+                    MessageQuote,
+                    MessageSuffix));
         }
 
         if (ClaudeCliLocator.TryResolvePathExecutable(
-                Environment.GetEnvironmentVariable("PATH"),
+                Environment.GetEnvironmentVariable(TestConstants.PathEnvironmentVariable),
                 OperatingSystem.IsWindows(),
                 out var pathExecutable))
         {
             return pathExecutable;
         }
 
-        throw new InvalidOperationException("Failed to resolve Claude Code CLI path.");
+        throw new InvalidOperationException(FailedToResolveExecutablePathMessage);
     }
 
     private static string CreateSandboxDirectory()
     {
         var sandboxDirectory = Path.Combine(
             ResolveRepositoryRootPath(),
-            "tests",
-            SandboxDirectoryName,
-            $"{SandboxPrefix}{Guid.NewGuid():N}");
+            TestConstants.TestsDirectoryName,
+            TestConstants.SandboxDirectoryName,
+            string.Concat(SandboxPrefix, Guid.NewGuid().ToString(TestConstants.NumericGuidFormat)));
         Directory.CreateDirectory(sandboxDirectory);
         return sandboxDirectory;
     }
 
     private static Dictionary<string, string> CreateUnauthenticatedEnvironmentOverrides(string sandboxDirectory)
     {
-        var claudeConfigDirectory = Path.Combine(sandboxDirectory, ".claude");
-        var configHome = Path.Combine(sandboxDirectory, ".config");
-        var appData = Path.Combine(sandboxDirectory, "AppData", "Roaming");
-        var localAppData = Path.Combine(sandboxDirectory, "AppData", "Local");
+        var claudeConfigDirectory = Path.Combine(sandboxDirectory, ClaudeConfigDirectoryName);
+        var configHome = Path.Combine(sandboxDirectory, ConfigDirectoryName);
+        var appData = Path.Combine(sandboxDirectory, TestConstants.AppDataDirectoryName, TestConstants.RoamingDirectoryName);
+        var localAppData = Path.Combine(sandboxDirectory, TestConstants.AppDataDirectoryName, TestConstants.LocalDirectoryName);
 
         Directory.CreateDirectory(claudeConfigDirectory);
         Directory.CreateDirectory(configHome);
@@ -135,8 +166,8 @@ private static Dictionary<string, string> CreateUnauthenticatedEnvironmentOverri
             [AppDataEnvironmentVariable] = appData,
             [LocalAppDataEnvironmentVariable] = localAppData,
             [ClaudeConfigDirEnvironmentVariable] = claudeConfigDirectory,
-            [AnthropicApiKeyEnvironmentVariable] = string.Empty,
-            [AnthropicBaseUrlEnvironmentVariable] = string.Empty,
+            [AnthropicApiKeyEnvironmentVariable] = TestConstants.EmptyString,
+            [AnthropicBaseUrlEnvironmentVariable] = TestConstants.EmptyString,
         };
     }
 
@@ -145,15 +176,15 @@ private static string ResolveRepositoryRootPath()
         var current = new DirectoryInfo(AppContext.BaseDirectory);
         while (current is not null)
         {
-            if (File.Exists(Path.Combine(current.FullName, SolutionFileName)))
+            if (File.Exists(Path.Combine(current.FullName, TestConstants.SolutionFileName)))
             {
                 return current.FullName;
             }
 
             current = current.Parent;
         }
 
-        throw new InvalidOperationException("Could not locate repository root from test execution directory.");
+        throw new InvalidOperationException(CouldNotLocateRepositoryRootMessage);
     }
 
     private static async Task<ClaudeProcessResult> RunClaudeAsync(
@@ -185,7 +216,14 @@ private static async Task<ClaudeProcessResult> RunClaudeAsync(
         using var process = new Process { StartInfo = startInfo };
         if (!process.Start())
         {
-            throw new InvalidOperationException($"Failed to start Claude Code CLI at '{executablePath}'.");
+            throw new InvalidOperationException(
+                string.Concat(
+                    StartProcessFailedMessagePrefix,
+                    Space,
+                    MessageQuote,
+                    executablePath,
+                    MessageQuote,
+                    MessageSuffix));
         }
 
         var standardOutputTask = process.StandardOutput.ReadToEndAsync();

ClaudeCodeSharpSDK.Tests/Integration/RealClaudeIntegrationTests.cs

@@ -3,10 +3,12 @@
 
 namespace ManagedCode.ClaudeCodeSharpSDK.Tests.Integration;
 
-[Property("RequiresClaudeAuth", "true")]
+[Property(TestConstants.RequiresClaudeAuthPropertyName, TestConstants.TrueString)]
 [RequiresAuthenticatedClaude]
 public class RealClaudeIntegrationTests
 {
+    private const string ReplyWithOkOnlyPrompt = "Reply with OK only.";
+
     [Test]
     public async Task RealClaude_RunAsync_WhenAuthenticated_ReturnsResponse()
     {
@@ -21,7 +23,7 @@ public async Task RealClaude_RunAsync_WhenAuthenticated_ReturnsResponse()
                 NoSessionPersistence = true,
             });
 
-            var result = await thread.RunAsync("Reply with OK only.");
+            var result = await thread.RunAsync(ReplyWithOkOnlyPrompt);
 
             await Assert.That(string.IsNullOrWhiteSpace(result.FinalResponse)).IsFalse();
         }

ClaudeCodeSharpSDK.Tests/MEAI/ChatMessageMapperTests.cs

@@ -5,21 +5,30 @@ namespace ManagedCode.ClaudeCodeSharpSDK.Extensions.AI.Tests;
 
 public class ChatMessageMapperTests
 {
+    private const string SystemPrompt = "Be concise";
+    private const string FirstQuestion = "First question";
+    private const string FirstAnswer = "First answer";
+    private const string FollowUp = "Follow up";
+    private const string ExtraContext = "With extra context";
+    private const string ExpectedPrompt = "[System] Be concise\n\nFirst question\n\n[Assistant] First answer\n\nFollow up\n\nWith extra context";
+    private const string DescribeImagePrompt = "Describe this image";
+    private const string PngMimeType = "image/png";
+    private const string TextOnlyPromptsMessage = "text-only prompts";
+
     [Test]
     public async Task ToClaudeInput_MixedConversation_PreservesChronology()
     {
         var messages = new[]
         {
-            new ChatMessage(ChatRole.System, "Be concise"),
-            new ChatMessage(ChatRole.User, "First question"),
-            new ChatMessage(ChatRole.Assistant, "First answer"),
-            new ChatMessage(ChatRole.User, [new TextContent("Follow up"), new TextContent("With extra context")]),
+            new ChatMessage(ChatRole.System, SystemPrompt),
+            new ChatMessage(ChatRole.User, FirstQuestion),
+            new ChatMessage(ChatRole.Assistant, FirstAnswer),
+            new ChatMessage(ChatRole.User, [new TextContent(FollowUp), new TextContent(ExtraContext)]),
         };
 
         var prompt = ChatMessageMapper.ToClaudeInput(messages);
 
-        await Assert.That(prompt).IsEqualTo(
-            "[System] Be concise\n\nFirst question\n\n[Assistant] First answer\n\nFollow up\n\nWith extra context");
+        await Assert.That(prompt).IsEqualTo(ExpectedPrompt);
     }
 
     [Test]
@@ -42,13 +51,13 @@ public async Task ToClaudeInput_ImageContent_ThrowsNotSupportedException()
             new ChatMessage(
                 ChatRole.User,
                 [
-                    new TextContent("Describe this image"),
-                    new DataContent(new byte[] { 0x89, 0x50, 0x4E, 0x47 }, "image/png"),
+                    new TextContent(DescribeImagePrompt),
+                    new DataContent(new byte[] { 0x89, 0x50, 0x4E, 0x47 }, PngMimeType),
                 ]),
         };
 
         var exception = await Assert.That(() => ChatMessageMapper.ToClaudeInput(messages)).ThrowsException();
         await Assert.That(exception).IsTypeOf<NotSupportedException>();
-        await Assert.That(exception!.Message).Contains("text-only prompts");
+        await Assert.That(exception!.Message).Contains(TextOnlyPromptsMessage);
     }
 }