gemini

KSemenenko · KSemenenko · commit 2fcfd3b5786d · 2026-03-18T22:04:46.000+01:00
diff --git a/DotPilot.Core/AgentBuilder/Services/AgentPromptDraftGenerator.cs b/DotPilot.Core/AgentBuilder/Services/AgentPromptDraftGenerator.cs
@@ -102,6 +102,14 @@ private async ValueTask<ProviderStatusDescriptor> ResolvePreferredProviderAsync(
             }
         }
 
+        var firstCreatableRealProvider = providers.FirstOrDefault(static provider =>
+            provider.CanCreateAgents &&
+            provider.Kind != AgentProviderKind.Debug);
+        if (firstCreatableRealProvider is not null)
+        {
+            return firstCreatableRealProvider;
+        }
+
         return providers.FirstOrDefault(static provider => provider.Kind == AgentProviderKind.Debug)
             ?? new ProviderStatusDescriptor(
                 AgentSessionDeterministicIdentity.CreateProviderId("debug"),
@@ -125,6 +133,7 @@ private static IEnumerable<AgentProviderKind> ResolveProviderPreferences(string
         {
             yield return AgentProviderKind.Codex;
             yield return AgentProviderKind.GitHubCopilot;
+            yield return AgentProviderKind.Gemini;
             yield return AgentProviderKind.ClaudeCode;
             yield return AgentProviderKind.Debug;
             yield break;
@@ -133,13 +142,15 @@ private static IEnumerable<AgentProviderKind> ResolveProviderPreferences(string
         if (ContainsAny(prompt, "research", "search", "summarize", "summary", "writing", "content", "docs", "analysis"))
         {
             yield return AgentProviderKind.ClaudeCode;
+            yield return AgentProviderKind.Gemini;
             yield return AgentProviderKind.Codex;
             yield return AgentProviderKind.GitHubCopilot;
             yield return AgentProviderKind.Debug;
             yield break;
         }
 
         yield return AgentProviderKind.Codex;
+        yield return AgentProviderKind.Gemini;
         yield return AgentProviderKind.ClaudeCode;
         yield return AgentProviderKind.GitHubCopilot;
         yield return AgentProviderKind.Debug;
diff --git a/DotPilot.Core/ChatSessions/Diagnostics/AgentExecutionLoggingMiddleware.ChatClient.cs b/DotPilot.Core/ChatSessions/Diagnostics/AgentExecutionLoggingMiddleware.ChatClient.cs
@@ -41,7 +41,7 @@ private IChatClient WrapChatClient(IChatClient chatClient, AgentRunLogContext ru
 
     private static bool ShouldBridgeSystemInstructions(AgentProviderKind providerKind)
     {
-        return providerKind is AgentProviderKind.Codex or AgentProviderKind.ClaudeCode;
+        return providerKind is AgentProviderKind.Codex or AgentProviderKind.ClaudeCode or AgentProviderKind.Gemini;
     }
 
     private async Task<ChatResponse> LogChatResponseAsync(
diff --git a/DotPilot.Core/ChatSessions/Execution/AgentRuntimeConversationFactory.cs b/DotPilot.Core/ChatSessions/Execution/AgentRuntimeConversationFactory.cs
@@ -6,12 +6,17 @@
 using ManagedCode.CodexSharpSDK.Client;
 using ManagedCode.CodexSharpSDK.Configuration;
 using ManagedCode.CodexSharpSDK.Extensions.AI;
+using ManagedCode.GeminiSharpSDK.Configuration;
+using ManagedCode.GeminiSharpSDK.Extensions.AI;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using ClaudeThreadOptions = ManagedCode.ClaudeCodeSharpSDK.Client.ThreadOptions;
 using CodexThreadOptions = ManagedCode.CodexSharpSDK.Client.ThreadOptions;
+using GeminiApprovalMode = ManagedCode.GeminiSharpSDK.Client.ApprovalMode;
+using GeminiSandboxMode = ManagedCode.GeminiSharpSDK.Client.SandboxMode;
+using GeminiThreadOptions = ManagedCode.GeminiSharpSDK.Client.ThreadOptions;
 
 namespace DotPilot.Core.ChatSessions;
 
@@ -210,6 +215,26 @@ private IChatClient CreateChatClient(
             });
         }
 
+        if (providerKind == AgentProviderKind.Gemini)
+        {
+            var geminiExecutablePath = ResolveExecutablePath(providerKind);
+            return new GeminiChatClient(new GeminiChatClientOptions
+            {
+                GeminiOptions = new GeminiOptions
+                {
+                    GeminiExecutablePath = geminiExecutablePath,
+                },
+                DefaultModel = modelName,
+                DefaultThreadOptions = new GeminiThreadOptions
+                {
+                    Model = modelName,
+                    WorkingDirectory = ResolvePlaygroundDirectory(sessionId),
+                    SandboxMode = GeminiSandboxMode.WorkspaceWrite,
+                    ApprovalPolicy = GeminiApprovalMode.Yolo,
+                },
+            });
+        }
+
         throw new InvalidOperationException(
             string.Format(
                 CultureInfo.InvariantCulture,
diff --git a/DotPilot.Core/ChatSessions/Models/AgentSessionStates.cs b/DotPilot.Core/ChatSessions/Models/AgentSessionStates.cs
@@ -6,6 +6,7 @@ public enum AgentProviderKind
     Codex,
     ClaudeCode,
     GitHubCopilot,
+    Gemini,
 }
 
 public enum AgentProviderStatus
diff --git a/DotPilot.Core/Providers/Configuration/AgentProviderKindExtensions.cs b/DotPilot.Core/Providers/Configuration/AgentProviderKindExtensions.cs
@@ -1,3 +1,5 @@
+using ManagedCode.GeminiSharpSDK.Models;
+
 namespace DotPilot.Core.Providers;
 
 internal static class AgentProviderKindExtensions
@@ -10,6 +12,7 @@ public static string GetCommandName(this AgentProviderKind kind)
             AgentProviderKind.Codex => "codex",
             AgentProviderKind.ClaudeCode => "claude",
             AgentProviderKind.GitHubCopilot => "copilot",
+            AgentProviderKind.Gemini => "gemini",
             _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
         };
     }
@@ -22,6 +25,7 @@ public static string GetDefaultModelName(this AgentProviderKind kind)
             AgentProviderKind.Codex => "gpt-5",
             AgentProviderKind.ClaudeCode => "claude-sonnet-4-5",
             AgentProviderKind.GitHubCopilot => "gpt-5",
+            AgentProviderKind.Gemini => GeminiModels.Gemini25Pro,
             _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
         };
     }
@@ -34,6 +38,7 @@ public static string GetDisplayName(this AgentProviderKind kind)
             AgentProviderKind.Codex => "Codex",
             AgentProviderKind.ClaudeCode => "Claude Code",
             AgentProviderKind.GitHubCopilot => "GitHub Copilot",
+            AgentProviderKind.Gemini => "Gemini",
             _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
         };
     }
@@ -46,6 +51,7 @@ public static string GetInstallCommand(this AgentProviderKind kind)
             AgentProviderKind.Codex => "npm install -g @openai/codex",
             AgentProviderKind.ClaudeCode => "npm install -g @anthropic-ai/claude-code",
             AgentProviderKind.GitHubCopilot => "npm install -g @github/copilot",
+            AgentProviderKind.Gemini => "npm install -g @google/gemini-cli",
             _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
         };
     }
@@ -58,6 +64,12 @@ public static IReadOnlyList<string> GetSupportedModelNames(this AgentProviderKin
             AgentProviderKind.Codex => [],
             AgentProviderKind.ClaudeCode => [],
             AgentProviderKind.GitHubCopilot => [],
+            AgentProviderKind.Gemini =>
+            [
+                GeminiModels.Gemini25Pro,
+                GeminiModels.Gemini25Flash,
+                GeminiModels.Gemini25FlashLite,
+            ],
             _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
         };
     }
diff --git a/DotPilot.Core/Providers/Services/AgentProviderStatusSnapshotReader.cs b/DotPilot.Core/Providers/Services/AgentProviderStatusSnapshotReader.cs
@@ -173,6 +173,7 @@ private static async ValueTask<ProviderCliMetadataSnapshot> ResolveMetadataAsync
             AgentProviderKind.GitHubCopilot => await CopilotCliMetadataReader.TryReadAsync(
                 executablePath,
                 cancellationToken).ConfigureAwait(false),
+            AgentProviderKind.Gemini => GeminiCliMetadataReader.TryRead(executablePath),
             _ => new ProviderCliMetadataSnapshot(null, null, []),
         };
     }
diff --git a/DotPilot.Core/Providers/Services/GeminiCliMetadataReader.cs b/DotPilot.Core/Providers/Services/GeminiCliMetadataReader.cs
@@ -0,0 +1,50 @@
+using ManagedCode.GeminiSharpSDK.Client;
+using ManagedCode.GeminiSharpSDK.Configuration;
+
+namespace DotPilot.Core.Providers;
+
+internal static class GeminiCliMetadataReader
+{
+    public static ProviderCliMetadataSnapshot TryRead(string executablePath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(executablePath);
+
+        try
+        {
+            using var client = new GeminiClient(new GeminiOptions
+            {
+                GeminiExecutablePath = executablePath,
+            });
+
+            var metadata = client.GetCliMetadata();
+            var supportedModels = metadata.Models
+                .Where(static model => model.IsListed)
+                .Select(static model => model.Slug)
+                .ToArray();
+
+            return new ProviderCliMetadataSnapshot(
+                metadata.InstalledVersion,
+                ResolveSuggestedModel(metadata.DefaultModel, supportedModels),
+                supportedModels);
+        }
+        catch
+        {
+            var fallbackModel = AgentProviderKind.Gemini.GetDefaultModelName();
+            return new ProviderCliMetadataSnapshot(
+                InstalledVersion: null,
+                fallbackModel,
+                AgentProviderKind.Gemini.GetSupportedModelNames());
+        }
+    }
+
+    private static string ResolveSuggestedModel(string? configuredModel, IReadOnlyList<string> supportedModels)
+    {
+        if (!string.IsNullOrWhiteSpace(configuredModel))
+        {
+            return configuredModel;
+        }
+
+        return supportedModels.FirstOrDefault(static model => !string.IsNullOrWhiteSpace(model)) ??
+            AgentProviderKind.Gemini.GetDefaultModelName();
+    }
+}
diff --git a/DotPilot.Tests/AgentBuilder/Services/AgentPromptDraftGeneratorTests.cs b/DotPilot.Tests/AgentBuilder/Services/AgentPromptDraftGeneratorTests.cs
@@ -45,6 +45,24 @@ public async Task CreateManualDraftAsyncUsesDefaultDebugFallback()
         draft.ModelName.Should().Be("debug-echo");
     }
 
+    [Test]
+    public async Task CreateManualDraftAsyncUsesGeminiWhenItIsTheOnlyEnabledRealProvider()
+    {
+        using var commandScope = CodexCliTestScope.Create(nameof(AgentPromptDraftGeneratorTests));
+        commandScope.WriteVersionCommand("gemini", "gemini-cli 0.34.0");
+        commandScope.WriteGeminiMetadata("gemini-2.5-pro", "gemini-2.5-pro", "gemini-2.5-flash");
+
+        await using var fixture = CreateFixture();
+        (await fixture.WorkspaceState.UpdateProviderAsync(
+            new UpdateProviderPreferenceCommand(AgentProviderKind.Gemini, true),
+            CancellationToken.None)).ShouldSucceed();
+
+        var draft = await fixture.Generator.CreateManualDraftAsync(CancellationToken.None);
+
+        draft.ProviderKind.Should().Be(AgentProviderKind.Gemini);
+        draft.ModelName.Should().Be("gemini-2.5-pro");
+    }
+
     private static TestFixture CreateFixture()
     {
         var services = new ServiceCollection();
diff --git a/DotPilot.Tests/AgentBuilder/ViewModels/AgentBuilderModelTests.cs b/DotPilot.Tests/AgentBuilder/ViewModels/AgentBuilderModelTests.cs
@@ -216,6 +216,29 @@ public async Task HandleProviderSelectionChangedUsesProviderKindParameterWhenNoP
         (await model.SelectedProvider)!.Kind.Should().Be(AgentProviderKind.ClaudeCode);
     }
 
+    [Test]
+    public async Task HandleProviderSelectionChangedUsesGeminiProviderKindParameterWhenNoProviderOptionIsProvided()
+    {
+        using var commandScope = CodexCliTestScope.Create(nameof(AgentBuilderModelTests));
+        commandScope.WriteVersionCommand("gemini", "gemini-cli 0.34.0");
+        commandScope.WriteGeminiMetadata("gemini-2.5-pro", "gemini-2.5-pro", "gemini-2.5-flash");
+
+        await using var fixture = await CreateFixtureAsync();
+        (await fixture.WorkspaceState.UpdateProviderAsync(
+            new UpdateProviderPreferenceCommand(AgentProviderKind.Gemini, true),
+            CancellationToken.None)).ShouldSucceed();
+
+        var model = ActivatorUtilities.CreateInstance<AgentBuilderModel>(fixture.Provider);
+
+        await model.BuildManually(CancellationToken.None);
+        await model.HandleProviderSelectionChanged(AgentProviderKind.Gemini, CancellationToken.None);
+
+        (await model.BuilderProviderDisplayName).Should().Be("Gemini");
+        (await model.BuilderSuggestedModelName).Should().Be("gemini-2.5-pro");
+        (await model.SelectedProvider).Should().NotBeNull();
+        (await model.SelectedProvider)!.Kind.Should().Be(AgentProviderKind.Gemini);
+    }
+
     [Test]
     public async Task HandleProviderSelectionChangedUsesTheProvidedProviderWhenThePreviousProviderRemainsPopulated()
     {
diff --git a/DotPilot.Tests/ChatSessions/Execution/AgentSessionServiceTests.cs b/DotPilot.Tests/ChatSessions/Execution/AgentSessionServiceTests.cs
@@ -28,7 +28,7 @@ public async Task GetWorkspaceAsyncSeedsDefaultSystemAgentForANewStore()
             agent.Name == AgentSessionDefaults.SystemAgentName &&
             agent.ProviderKind == AgentProviderKind.Debug &&
             agent.ModelName == AgentSessionDefaults.GetDefaultModel(AgentProviderKind.Debug));
-        workspace.Providers.Should().HaveCount(4);
+        workspace.Providers.Should().HaveCount(5);
         workspace.Providers.Should().ContainSingle(provider => provider.Kind == AgentProviderKind.Debug);
         workspace.Providers.Should().ContainSingle(provider =>
             provider.Kind == AgentProviderKind.Debug &&
diff --git a/DotPilot.Tests/ChatSessions/Execution/RealProviderSessionSmokeTests.cs b/DotPilot.Tests/ChatSessions/Execution/RealProviderSessionSmokeTests.cs
@@ -34,6 +34,7 @@ public sealed class RealProviderSessionSmokeTests
     [TestCase(AgentProviderKind.Codex, "Codex")]
     [TestCase(AgentProviderKind.ClaudeCode, "Claude Code")]
     [TestCase(AgentProviderKind.GitHubCopilot, "GitHub Copilot")]
+    [TestCase(AgentProviderKind.Gemini, "Gemini")]
     public async Task CreateAgentAndSendHelloWorksForRealProviderWhenRuntimeIsAvailable(
         AgentProviderKind providerKind,
         string providerDisplayName)
diff --git a/DotPilot.Tests/Providers/Services/AgentProviderStatusReaderTests.cs b/DotPilot.Tests/Providers/Services/AgentProviderStatusReaderTests.cs
@@ -174,6 +174,31 @@ public async Task EnabledClaudeProviderReportsReadyRuntimeAndSuggestedModels()
             detail.Value.Contains("claude-opus-4-6", StringComparison.Ordinal));
     }
 
+    [Test]
+    public async Task EnabledGeminiProviderReportsReadyRuntimeAndSuggestedModels()
+    {
+        using var commandScope = CodexCliTestScope.Create(nameof(AgentProviderStatusReaderTests));
+        commandScope.WriteVersionCommand("gemini", "gemini-cli 0.34.0");
+        commandScope.WriteGeminiMetadata("gemini-2.5-pro", "gemini-2.5-pro", "gemini-2.5-flash");
+
+        await using var fixture = CreateFixture();
+        var provider = (await fixture.Service.UpdateProviderAsync(
+            new UpdateProviderPreferenceCommand(AgentProviderKind.Gemini, true),
+            CancellationToken.None)).ShouldSucceed();
+
+        provider.IsEnabled.Should().BeTrue();
+        provider.CanCreateAgents.Should().BeTrue();
+        provider.Status.Should().Be(AgentProviderStatus.Ready);
+        provider.StatusSummary.Should().Contain("ready for local desktop execution");
+        provider.InstalledVersion.Should().Be("0.34.0");
+        provider.SuggestedModelName.Should().Be("gemini-2.5-pro");
+        provider.SupportedModelNames.Should().Contain("gemini-2.5-flash");
+        provider.Details.Should().Contain(detail => detail.Label == "Suggested model" && detail.Value == "gemini-2.5-pro");
+        provider.Details.Should().Contain(detail =>
+            detail.Label == "Supported models" &&
+            detail.Value.Contains("gemini-2.5-flash", StringComparison.Ordinal));
+    }
+
     [Test]
     public async Task ConcurrentReadsShareOneInFlightProviderProbe()
     {
diff --git a/DotPilot.Tests/Providers/Services/CodexCliTestScope.cs b/DotPilot.Tests/Providers/Services/CodexCliTestScope.cs
@@ -204,6 +204,49 @@ public void WriteCopilotConfig(string model)
             }));
     }
 
+    public void WriteGeminiMetadata(
+        string defaultModel,
+        params string[] models)
+    {
+        var configDirectory = Path.Combine(
+            Environment.GetEnvironmentVariable("HOME") ?? rootPath,
+            ".gemini");
+        Directory.CreateDirectory(configDirectory);
+        File.WriteAllText(
+            Path.Combine(configDirectory, "config.toml"),
+            string.Join(
+                Environment.NewLine,
+                $"model = \"{defaultModel}\"",
+                string.Empty));
+
+        var payload = new
+        {
+            models = models.Select(model => new
+            {
+                slug = model,
+                display_name = model,
+                description = $"Test model {model}",
+                visibility = "list",
+                supported_in_api = true,
+                supported_reasoning_levels = new[]
+                {
+                    new
+                    {
+                        effort = "low",
+                    },
+                    new
+                    {
+                        effort = "high",
+                    },
+                },
+            }),
+        };
+
+        File.WriteAllText(
+            Path.Combine(configDirectory, "models_cache.json"),
+            JsonSerializer.Serialize(payload));
+    }
+
     private string GetCounterFilePath(string commandName)
     {
         return Path.Combine(rootPath, commandName + ".count");
diff --git a/DotPilot.Tests/Settings/ViewModels/SettingsModelTests.cs b/DotPilot.Tests/Settings/ViewModels/SettingsModelTests.cs
diff --git a/DotPilot/Presentation/AgentBuilder/ViewModels/AgentBuilderModel.cs b/DotPilot/Presentation/AgentBuilder/ViewModels/AgentBuilderModel.cs
diff --git a/DotPilot/Presentation/Chat/ViewModels/ChatModel.cs b/DotPilot/Presentation/Chat/ViewModels/ChatModel.cs
diff --git a/DotPilot/Presentation/Settings/ViewModels/SettingsModel.cs b/DotPilot/Presentation/Settings/ViewModels/SettingsModel.cs

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ private IChatClient WrapChatClient(IChatClient chatClient, AgentRunLogContext ru`
`41`	`41`
`42`	`42`	`private static bool ShouldBridgeSystemInstructions(AgentProviderKind providerKind)`
`43`	`43`	`{`
`44`		`- return providerKind is AgentProviderKind.Codex or AgentProviderKind.ClaudeCode;`
	`44`	`+ return providerKind is AgentProviderKind.Codex or AgentProviderKind.ClaudeCode or AgentProviderKind.Gemini;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`private async Task<ChatResponse> LogChatResponseAsync(`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ public enum AgentProviderKind`
`6`	`6`	`Codex,`
`7`	`7`	`ClaudeCode,`
`8`	`8`	`GitHubCopilot,`
	`9`	`+ Gemini,`
`9`	`10`	`}`
`10`	`11`
`11`	`12`	`public enum AgentProviderStatus`
Original file line number	Diff line number	Diff line change
`@@ -173,6 +173,7 @@ private static async ValueTask<ProviderCliMetadataSnapshot> ResolveMetadataAsync`
`173`	`173`	`AgentProviderKind.GitHubCopilot => await CopilotCliMetadataReader.TryReadAsync(`
`174`	`174`	`executablePath,`
`175`	`175`	`cancellationToken).ConfigureAwait(false),`
	`176`	`+ AgentProviderKind.Gemini => GeminiCliMetadataReader.TryRead(executablePath),`
`176`	`177`	`_ => new ProviderCliMetadataSnapshot(null, null, []),`
`177`	`178`	`};`
`178`	`179`	`}`