fix: tighten follow-up review edge cases

Author: vicary

README.md

@@ -231,6 +231,10 @@ top-level aliases remain supported for backward compatibility. Precedence is:
 1. `redis.*` (canonical)
 2. top-level Graphiti aliases such as `endpoint` and `groupIdPrefix`
 
+Endpoint values must be valid URLs, so include the scheme explicitly - for
+example `redis://localhost:6379` for Redis and `http://localhost:8000/mcp` for
+Graphiti.
+
 ### Legacy Top-Level Keys
 
 For backward compatibility, the following original Graphiti top-level keys are

src/services/connection-manager.test.ts

@@ -792,6 +792,34 @@ describe("connection manager", () => {
     assertEquals(aborted, true);
   });
 
+  it("maps AbortError rejections during shutdown to GraphitiOfflineError", async () => {
+    const manager = new GraphitiConnectionManager({
+      endpoint: "http://test",
+      connectionFactory: () => ({
+        connect: () => Promise.resolve(),
+        close: () => Promise.resolve(),
+        callTool: (_request, options) =>
+          new Promise<unknown>((_resolve, reject) => {
+            options?.signal?.addEventListener("abort", () => {
+              reject(new DOMException("aborted", "AbortError"));
+            }, { once: true });
+          }),
+      }),
+    });
+
+    manager.start();
+    assertEquals(await manager.ready(10), true);
+
+    const request = manager.callTool("search", {});
+    await manager.stop();
+
+    const error = await assertRejects(
+      () => request,
+      GraphitiOfflineError,
+    );
+    assertEquals(error.state, "closing");
+  });
+
   it("stop keeps reconnect from transitioning back to connected", async () => {
     let connectionIndex = 0;
     let failed = false;

src/services/connection-manager.ts

@@ -214,6 +214,15 @@ function isSessionExpired(err: unknown): boolean {
   );
 }
 
+function isAbortError(err: unknown): boolean {
+  if (!err || typeof err !== "object") return false;
+  if (typeof (err as { name?: unknown }).name === "string") {
+    return (err as { name: string }).name === "AbortError";
+  }
+  return typeof DOMException !== "undefined" && err instanceof DOMException &&
+    err.name === "AbortError";
+}
+
 function isTransportFailure(err: unknown): boolean {
   if (!err) return false;
   if (isRequestTimeout(err) || isSessionExpired(err)) return false;
@@ -497,6 +506,14 @@ export class GraphitiConnectionManager implements GraphitiToolCaller {
         controller,
       );
     } catch (err) {
+      if (err instanceof GraphitiOfflineError) {
+        throw err;
+      }
+
+      if (this.stopPromise && isAbortError(err)) {
+        throw new GraphitiOfflineError("closing");
+      }
+
       if (isRequestTimeout(err)) {
         throw new GraphitiRequestTimeoutError(
           getErrorMessage(err) || undefined,

src/services/context-limit.test.ts

@@ -1,12 +1,12 @@
 import { assertEquals } from "jsr:@std/assert@^1.0.0";
-import { resolveContextLimit } from "./context-limit.ts";
+import {
+  type ContextLimitCacheEntry,
+  resolveContextLimit,
+} from "./context-limit.ts";
 
 Deno.test("resolveContextLimit re-probes after fallback cache expiry", async () => {
   let now = 100_000;
-  const cache = new Map<
-    string,
-    number | { value: number; expiresAt?: number }
-  >();
+  const cache = new Map<string, ContextLimitCacheEntry>();
   let calls = 0;
   const client = {
     provider: {
@@ -70,10 +70,7 @@ Deno.test("resolveContextLimit re-probes after fallback cache expiry", async ()
 
 Deno.test("resolveContextLimit keeps fallback caches scoped per normalized directory until expiry", async () => {
   let now = 200_000;
-  const cache = new Map<
-    string,
-    number | { value: number; expiresAt?: number }
-  >();
+  const cache = new Map<string, ContextLimitCacheEntry>();
   const calls: string[] = [];
   const client = {
     provider: {
@@ -158,10 +155,7 @@ Deno.test("resolveContextLimit keeps fallback caches scoped per normalized direc
 });
 
 Deno.test("resolveContextLimit keeps positive cache entries without expiry re-probes", async () => {
-  const cache = new Map<
-    string,
-    number | { value: number; expiresAt?: number }
-  >();
+  const cache = new Map<string, ContextLimitCacheEntry>();
   let calls = 0;
   const client = {
     provider: {
@@ -204,10 +198,7 @@ Deno.test("resolveContextLimit keeps positive cache entries without expiry re-pr
 });
 
 Deno.test("resolveContextLimit re-probes when legacy numeric cache entry is non-positive", async () => {
-  const cache = new Map<
-    string,
-    number | { value: number; expiresAt?: number }
-  >();
+  const cache = new Map<string, ContextLimitCacheEntry>();
   cache.set("openai/gpt-5", -1);
 
   let calls = 0;
@@ -243,10 +234,7 @@ Deno.test("resolveContextLimit re-probes when legacy numeric cache entry is non-
 });
 
 Deno.test("resolveContextLimit re-probes when legacy object cache entry is non-positive without expiry", async () => {
-  const cache = new Map<
-    string,
-    number | { value: number; expiresAt?: number }
-  >();
+  const cache = new Map<string, ContextLimitCacheEntry>();
   cache.set("openai/gpt-5", { value: -1 });
 
   let calls = 0;