Fix HttpRetryPolicy: fail fast on unreachable services

- Add per-attempt timeout support and Ollama-specific timeout

- Avoid retrying connection-refused/host-not-found to prevent long-running test hangs

Author: dluc

src/Core/Constants.cs

@@ -220,6 +220,18 @@ public static class HttpRetryDefaults
         /// </summary>
         public const int MaxAttempts = 5;
 
+        /// <summary>
+        /// Default timeout per attempt (seconds).
+        /// Applied by <see cref="KernelMemory.Core.Http.HttpRetryPolicy"/> to avoid hanging calls.
+        /// </summary>
+        public const int DefaultPerAttemptTimeoutSeconds = 60;
+
+        /// <summary>
+        /// Per-attempt timeout for local Ollama calls (seconds).
+        /// Keep this low so local development and tests fail fast when Ollama is not running.
+        /// </summary>
+        public const int OllamaPerAttemptTimeoutSeconds = 5;
+
         /// <summary>
         /// Base delay for exponential backoff.
         /// </summary>

src/Core/Embeddings/Providers/OllamaEmbeddingGenerator.cs

@@ -92,7 +92,8 @@ public async Task<EmbeddingResult> GenerateAsync(string text, CancellationToken
             },
             this._logger,
             ct,
-            delayAsync: this._delayAsync).ConfigureAwait(false);
+            delayAsync: this._delayAsync,
+            perAttemptTimeout: TimeSpan.FromSeconds(Constants.HttpRetryDefaults.OllamaPerAttemptTimeoutSeconds)).ConfigureAwait(false);
 
         response.EnsureSuccessStatusCode();
 

src/Core/Http/HttpRetryPolicy.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System.Net;
+using System.Net.Sockets;
 using Microsoft.Extensions.Logging;
 
 namespace KernelMemory.Core.Http;
@@ -19,13 +20,15 @@ public static async Task<HttpResponseMessage> SendAsync(
         Func<HttpRequestMessage> requestFactory,
         ILogger logger,
         CancellationToken ct,
-        Func<TimeSpan, CancellationToken, Task>? delayAsync = null)
+        Func<TimeSpan, CancellationToken, Task>? delayAsync = null,
+        TimeSpan? perAttemptTimeout = null)
     {
         ArgumentNullException.ThrowIfNull(httpClient, nameof(httpClient));
         ArgumentNullException.ThrowIfNull(requestFactory, nameof(requestFactory));
         ArgumentNullException.ThrowIfNull(logger, nameof(logger));
 
         delayAsync ??= Task.Delay;
+        perAttemptTimeout ??= TimeSpan.FromSeconds(Constants.HttpRetryDefaults.DefaultPerAttemptTimeoutSeconds);
 
         Exception? lastException = null;
 
@@ -37,7 +40,10 @@ public static async Task<HttpResponseMessage> SendAsync(
 
             try
             {
-                var response = await httpClient.SendAsync(request, ct).ConfigureAwait(false);
+                using var attemptCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                attemptCts.CancelAfter(perAttemptTimeout.Value);
+
+                var response = await httpClient.SendAsync(request, attemptCts.Token).ConfigureAwait(false);
 
                 if (response.IsSuccessStatusCode)
                 {
@@ -81,7 +87,7 @@ public static async Task<HttpResponseMessage> SendAsync(
             catch (HttpRequestException ex)
             {
                 lastException = ex;
-                if (attempt == Constants.HttpRetryDefaults.MaxAttempts)
+                if (!IsRetryableException(ex) || attempt == Constants.HttpRetryDefaults.MaxAttempts)
                 {
                     throw;
                 }
@@ -101,6 +107,20 @@ public static async Task<HttpResponseMessage> SendAsync(
         throw lastException ?? new HttpRequestException("HTTP call failed after retries");
     }
 
+    private static bool IsRetryableException(HttpRequestException ex)
+    {
+        // Fail fast on common "service not running" / "unreachable" conditions.
+        // Retrying these (especially with default HttpClient timeouts) can make test runs appear hung.
+        if (ex.InnerException is SocketException socketEx)
+        {
+            return socketEx.SocketErrorCode != SocketError.ConnectionRefused &&
+                   socketEx.SocketErrorCode != SocketError.HostNotFound &&
+                   socketEx.SocketErrorCode != SocketError.NetworkUnreachable;
+        }
+
+        return true;
+    }
+
     private static bool IsRetryableStatusCode(HttpStatusCode statusCode)
     {
         return statusCode == HttpStatusCode.TooManyRequests ||