@assistant-ui/react-google-adk 0.0.34 → 0.0.36

package/src/useAdkRuntimeApproval.test.tsx

@@ -1,17 +1,48 @@
+/** @vitest-environment jsdom */
 import { act, renderHook } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type {
+  AddToolResultOptions,
+  AppendMessage,
   RespondToToolApprovalOptions,
   ThreadMessage,
   ToolCallMessagePart,
 } from "@assistant-ui/core";
-import type { AdkMessage } from "./types";
+import type {
+  AdkMessage,
+  AdkSendMessageConfig,
+  AdkThreadSnapshot,
+} from "./types";
 
-const mocks = vi.hoisted(() => ({
-  adapters: [] as unknown[],
-  sendMessage: vi.fn().mockResolvedValue(undefined),
-  messages: [] as AdkMessage[],
-}));
+const mocks = vi.hoisted(() => {
+  const threadListItem = {
+    source: null as object | null,
+    id: "thread-a",
+    externalId: undefined as string | undefined,
+    getState: () => ({
+      id: threadListItem.id,
+      externalId: threadListItem.externalId,
+    }),
+    initialize: vi.fn(),
+  };
+  return {
+    adapters: [] as unknown[],
+    sendMessage: vi.fn().mockResolvedValue(undefined),
+    messages: [] as AdkMessage[],
+    messageRunConfig: undefined as unknown,
+    streamedMessages: undefined as AdkMessage[] | undefined,
+    applySnapshot: vi.fn(),
+    threadListItem,
+  };
+});
+
+const mockController = {
+  subscribe: () => () => {},
+  getStagedMessageCount: () => 0,
+  getState: () => ({ messages: mocks.messages }),
+  dispatch: vi.fn(),
+  getStagedRun: () => null,
+};
 
 vi.mock("@assistant-ui/core/react", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/core/react")>()),
@@ -27,49 +58,96 @@ vi.mock("@assistant-ui/core/react", async (importOriginal) => ({
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
   useAui: () => ({
-    threadListItem: {
-      source: null,
-      getState: () => ({ externalId: undefined }),
-      initialize: vi.fn(),
+    threadListItem: mocks.threadListItem,
+    threads: {
+      getState: () => ({ mainThreadId: mocks.threadListItem.id }),
     },
   }),
 }));
 
-vi.mock("./useAdkMessages", async (importOriginal) => ({
-  ...(await importOriginal<typeof import("./useAdkMessages")>()),
-  useAdkMessages: () => ({
-    messages: mocks.messages,
-    stateDelta: {},
-    agentInfo: {},
-    longRunningToolIds: [],
-    artifactDelta: {},
-    // Deliberately empty: the projection must come from the transcript, not
-    // from derived confirmation state that a mid-run accumulator swap drops.
-    toolConfirmations: [],
-    authRequests: [],
-    escalated: false,
-    messageMetadata: new Map(),
-    sendMessage: mocks.sendMessage,
-    cancel: vi.fn(),
-    setMessages: vi.fn(),
-    replaceMessages: vi.fn(),
-    applySnapshot: vi.fn(),
-  }),
-}));
+vi.mock("./useAdkMessages", async (importOriginal) => {
+  const useMockAdkMessages = (options: {
+    onMessages?: (messages: AdkMessage[], runConfig: unknown) => void;
+  }) => {
+    options.onMessages?.(mocks.messages, mocks.messageRunConfig);
+    const sendMessage = async (
+      messages: AdkMessage[],
+      config: AdkSendMessageConfig,
+    ) => {
+      await mocks.sendMessage(messages, config);
+      if (mocks.streamedMessages) {
+        options.onMessages?.(mocks.streamedMessages, config.runConfig);
+      }
+    };
+    return {
+      controller: mockController,
+      messages: mocks.messages,
+      stateDelta: {},
+      agentInfo: {},
+      longRunningToolIds: [],
+      artifactDelta: {},
+      // Deliberately empty: the projection must come from the transcript, not
+      // from derived confirmation state that a mid-run accumulator swap drops.
+      toolConfirmations: [],
+      authRequests: [],
+      escalated: false,
+      messageMetadata: new Map(),
+      sendMessage,
+      cancel: vi.fn(),
+      setMessages: vi.fn(),
+      replaceMessages: vi.fn(),
+      applySnapshot: mocks.applySnapshot,
+    };
+  };
+
+  return {
+    ...(await importOriginal<typeof import("./useAdkMessages")>()),
+    useAdkMessages: useMockAdkMessages,
+    useAdkMessagesInternal: useMockAdkMessages,
+  };
+});
 
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
 import { useAdkRuntime } from "./useAdkRuntime";
 
-type ApprovalAdapter = {
+type RuntimeAdapter = {
   messages: readonly ThreadMessage[];
+  extras: {
+    send: (
+      messages: AdkMessage[],
+      config: AdkSendMessageConfig,
+    ) => Promise<void>;
+  };
+  onNew?: (message: AppendMessage) => Promise<void> | void;
+  onEdit?: (message: AppendMessage) => Promise<void> | void;
+  onAddToolResult?: (options: AddToolResultOptions) => Promise<void> | void;
   onRespondToToolApproval?: (
     options: RespondToToolApprovalOptions,
   ) => Promise<void> | void;
+  onReload?: (
+    parentId: string | null,
+    config: { runConfig?: AppendMessage["runConfig"] },
+  ) => Promise<void> | void;
+  onRefetchThread?: () => Promise<void> | void;
 };
 
 const CONFIRMATION_CALL = "adk-confirmation-1";
 
-const latestAdapter = () => mocks.adapters.at(-1) as ApprovalAdapter;
+const latestAdapter = () => mocks.adapters.at(-1) as RuntimeAdapter;
+
+const makeUserMessage = (
+  text: string,
+  runConfig: AppendMessage["runConfig"],
+): AppendMessage =>
+  ({
+    role: "user",
+    content: [{ type: "text", text }],
+    attachments: [],
+    parentId: null,
+    sourceId: null,
+    runConfig,
+    metadata: { custom: {} },
+  }) as unknown as AppendMessage;
 
 const makeConfirmationRequest = (): AdkMessage => ({
   id: "ai-1",
@@ -96,20 +174,293 @@ const approvalPart = () =>
 
 afterEach(() => {
   mocks.adapters.length = 0;
+  mocks.sendMessage.mockClear();
   mocks.messages = [];
+  mocks.messageRunConfig = undefined;
+  mocks.streamedMessages = undefined;
+  mocks.applySnapshot.mockReset();
+  mocks.threadListItem.source = null;
+  mocks.threadListItem.externalId = undefined;
 });
 
 describe("useAdkRuntime tool approvals", () => {
+  it.each([
+    "reload",
+    "tool result",
+    "approval response",
+    "extras send",
+  ] as const)("waits for the initial load before %s", async (route) => {
+    let resolveLoad!: (snapshot: AdkThreadSnapshot) => void;
+    const pendingLoad = new Promise<AdkThreadSnapshot>((resolve) => {
+      resolveLoad = resolve;
+    });
+    const load = vi.fn(() => pendingLoad);
+    mocks.threadListItem.source = {};
+    mocks.threadListItem.externalId = "thread-a";
+    renderHook(() =>
+      useAdkRuntime({
+        stream: vi.fn(),
+        load,
+        getCheckpointId: vi.fn(async () => null),
+      }),
+    );
+    expect(load).toHaveBeenCalledOnce();
+
+    let action: Promise<void>;
+    switch (route) {
+      case "reload":
+        action = Promise.resolve(latestAdapter().onReload!(null, {}));
+        break;
+      case "tool result":
+        action = Promise.resolve(
+          latestAdapter().onAddToolResult!({
+            messageId: "ai-1",
+            toolCallId: "tool-a",
+            toolName: "lookup",
+            result: { value: "done" },
+            isError: false,
+          }),
+        );
+        break;
+      case "approval response":
+        action = Promise.resolve(
+          latestAdapter().onRespondToToolApproval!({
+            approvalId: CONFIRMATION_CALL,
+            approved: true,
+          }),
+        );
+        break;
+      case "extras send":
+        action = latestAdapter().extras.send(
+          [{ id: "new-user", type: "human", content: "new question" }],
+          {},
+        );
+    }
+    void action.catch(() => {});
+    await Promise.resolve();
+    expect(mocks.sendMessage).not.toHaveBeenCalled();
+
+    await act(async () => {
+      resolveLoad({ messages: [makeConfirmationRequest()] });
+      await action;
+    });
+    expect(mocks.sendMessage).toHaveBeenCalledOnce();
+  });
+
+  it("resumes a delayed tool result with its originating run config", async () => {
+    const runConfigA = { custom: { model: "model-a" } };
+    const runConfigB = { custom: { model: "model-b" } };
+    const { rerender } = renderHook(() => useAdkRuntime({ stream: vi.fn() }));
+
+    await act(async () => {
+      await latestAdapter().onNew!(makeUserMessage("first", runConfigA));
+    });
+
+    mocks.messages = [
+      { id: "u-1", type: "human", content: "first" },
+      {
+        id: "ai-1",
+        type: "ai",
+        content: [],
+        tool_calls: [
+          {
+            id: "tool-a",
+            name: "lookup",
+            args: {},
+          },
+        ],
+      },
+    ];
+    mocks.messageRunConfig = runConfigA;
+    rerender();
+
+    await act(async () => {
+      await latestAdapter().onNew!(makeUserMessage("second", runConfigB));
+      await latestAdapter().onAddToolResult!({
+        messageId: "ai-1",
+        toolCallId: "tool-a",
+        toolName: "lookup",
+        result: { value: "done" },
+        isError: false,
+      });
+    });
+
+    expect(
+      mocks.sendMessage.mock.calls.map((call) => call[1].runConfig),
+    ).toEqual([runConfigA, runConfigB, runConfigA]);
+  });
+
+  it("preserves pending tool ownership across a thread refetch", async () => {
+    const runConfig = { custom: { model: "model-a" } };
+    const laterRunConfig = { custom: { model: "model-b" } };
+    const currentMessages: AdkMessage[] = [
+      {
+        id: "ai-1",
+        type: "ai",
+        content: [],
+        tool_calls: [{ id: "tool-a", name: "lookup", args: {} }],
+      },
+    ];
+    const loadedMessages: AdkMessage[] = [
+      ...currentMessages,
+      {
+        id: "ai-2",
+        type: "ai",
+        content: [],
+        tool_calls: [
+          null as never,
+          { id: "tool-loaded", name: "lookup", args: {} },
+        ],
+      },
+    ];
+    const load = vi.fn(async () => ({ messages: loadedMessages }));
+    mocks.threadListItem.source = {};
+
+    const { rerender } = renderHook(() =>
+      useAdkRuntime({ stream: vi.fn(), load }),
+    );
+
+    await act(async () => {
+      await latestAdapter().onNew!(makeUserMessage("first", runConfig));
+    });
+    mocks.messages = currentMessages;
+    mocks.messageRunConfig = runConfig;
+    rerender();
+
+    mocks.threadListItem.externalId = "thread-a";
+    rerender();
+    await act(async () => {
+      await latestAdapter().onRefetchThread!();
+    });
+
+    await act(async () => {
+      mocks.streamedMessages = [loadedMessages.at(-1)!];
+      await latestAdapter().extras.send(
+        [{ id: "u-later", type: "human", content: "later" }],
+        { runConfig: laterRunConfig },
+      );
+      mocks.streamedMessages = undefined;
+      await latestAdapter().onAddToolResult!({
+        messageId: "ai-1",
+        toolCallId: "tool-a",
+        toolName: "lookup",
+        result: { value: "done" },
+        isError: false,
+      });
+      await latestAdapter().onAddToolResult!({
+        messageId: "ai-2",
+        toolCallId: "tool-loaded",
+        toolName: "lookup",
+        result: { value: "loaded" },
+        isError: false,
+      });
+    });
+
+    expect(
+      mocks.sendMessage.mock.calls.slice(-2).map((call) => call[1]),
+    ).toEqual([{ runConfig }, { runConfig: undefined }]);
+  });
+
+  it("tracks and prunes ownership around malformed tool-call entries", async () => {
+    const runConfig = { custom: { model: "model-a" } };
+    mocks.messages = [
+      { id: "u-1", type: "human", content: "first" },
+      {
+        id: "ai-1",
+        type: "ai",
+        content: [],
+        tool_calls: [null as never, { id: "tool-a", name: "lookup", args: {} }],
+      },
+    ];
+    mocks.messageRunConfig = runConfig;
+    renderHook(() =>
+      useAdkRuntime({
+        stream: vi.fn(),
+        getCheckpointId: vi.fn(async () => null),
+      }),
+    );
+
+    await act(async () => {
+      await latestAdapter().onEdit!({
+        ...makeUserMessage("edited", runConfig),
+        parentId: "ai-1",
+      });
+      await latestAdapter().onAddToolResult!({
+        messageId: "ai-1",
+        toolCallId: "tool-a",
+        toolName: "lookup",
+        result: { value: "done" },
+        isError: false,
+      });
+    });
+
+    expect(mocks.sendMessage.mock.calls.at(-1)![1]).toEqual({ runConfig });
+  });
+
+  it("attributes new tool calls to an explicitly configured continuation", async () => {
+    const runConfigA = { custom: { model: "model-a" } };
+    const runConfigB = { custom: { model: "model-b" } };
+    renderHook(() => useAdkRuntime({ stream: vi.fn() }));
+
+    await act(async () => {
+      await latestAdapter().onNew!(makeUserMessage("first", runConfigA));
+      mocks.streamedMessages = [
+        {
+          id: "ai-b",
+          type: "ai",
+          content: [],
+          tool_calls: [{ id: "tool-b", name: "lookup", args: {} }],
+        },
+      ];
+      await latestAdapter().extras.send(
+        [
+          {
+            id: "tool-result-a",
+            type: "tool",
+            tool_call_id: "tool-a",
+            name: "lookup",
+            content: JSON.stringify({ value: "first" }),
+          },
+        ],
+        { runConfig: runConfigB },
+      );
+    });
+
+    await act(async () => {
+      await latestAdapter().onAddToolResult!({
+        messageId: "ai-b",
+        toolCallId: "tool-b",
+        toolName: "lookup",
+        result: { value: "second" },
+        isError: false,
+      });
+    });
+
+    expect(mocks.sendMessage.mock.calls.at(-1)![1]).toEqual({
+      runConfig: runConfigB,
+    });
+  });
+
   it("exposes, answers, and settles the default approval seam across a rerender", async () => {
+    const runConfig = { custom: { model: "model-a" } };
+    const nextRunConfig = { custom: { model: "model-b" } };
     // Retained across the rerender: core caches converted messages by input
     // object, so only a rebuilt converter can surface the settled decision.
     const confirmationRequest = makeConfirmationRequest();
+    const { rerender } = renderHook(() => useAdkRuntime({ stream: vi.fn() }));
+
+    await act(async () => {
+      await latestAdapter().onNew!(
+        makeUserMessage("delete the file", runConfig),
+      );
+    });
+
     mocks.messages = [
       { id: "u-1", type: "human", content: "delete the file" },
       confirmationRequest,
     ];
-
-    const { rerender } = renderHook(() => useAdkRuntime({ stream: vi.fn() }));
+    mocks.messageRunConfig = runConfig;
+    rerender();
 
     expect(latestAdapter().messages.at(-1)!.status).toMatchObject({
       type: "requires-action",
@@ -121,6 +472,9 @@ describe("useAdkRuntime tool approvals", () => {
     });
 
     await act(async () => {
+      await latestAdapter().onNew!(
+        makeUserMessage("start another run", nextRunConfig),
+      );
       await latestAdapter().onRespondToToolApproval!({
         approvalId: CONFIRMATION_CALL,
         approved: false,
@@ -135,6 +489,7 @@ describe("useAdkRuntime tool approvals", () => {
         content: JSON.stringify({ confirmed: false }),
       }),
     ]);
+    expect(mocks.sendMessage.mock.calls.at(-1)![1]).toEqual({ runConfig });
 
     mocks.messages = [
       ...mocks.messages,

package/dist/raceWithAbortSignal.d.ts

@@ -1,2 +0,0 @@
-export declare const raceWithAbortSignal: <T>(signal: AbortSignal | undefined, operation: () => T | PromiseLike<T>) => Promise<T>;
-//# sourceMappingURL=raceWithAbortSignal.d.ts.map

package/dist/raceWithAbortSignal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"raceWithAbortSignal.d.ts","sourceRoot":"","sources":["../src/raceWithAbortSignal.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB,GAAI,CAAC,EACnC,QAAQ,WAAW,GAAG,SAAS,EAC/B,WAAW,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAClC,OAAO,CAAC,CAAC,CAqCX,CAAC"}

package/dist/raceWithAbortSignal.js

@@ -1,45 +0,0 @@
-//#region src/raceWithAbortSignal.ts
-const getAbortReason = (signal) => {
-	if (signal.reason !== void 0) return signal.reason;
-	const error = /* @__PURE__ */ new Error("The operation was aborted");
-	error.name = "AbortError";
-	return error;
-};
-const raceWithAbortSignal = (signal, operation) => {
-	if (!signal) try {
-		return Promise.resolve(operation());
-	} catch (error) {
-		return Promise.reject(error);
-	}
-	if (signal.aborted) return Promise.reject(getAbortReason(signal));
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const cleanup = () => signal.removeEventListener("abort", handleAbort);
-		const resolveOnce = (value) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve(value);
-		};
-		const rejectOnce = (error) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(error);
-		};
-		const handleAbort = () => rejectOnce(getAbortReason(signal));
-		signal.addEventListener("abort", handleAbort, { once: true });
-		let result;
-		try {
-			result = operation();
-		} catch (error) {
-			rejectOnce(error);
-			return;
-		}
-		Promise.resolve(result).then(resolveOnce, rejectOnce);
-	});
-};
-//#endregion
-export { raceWithAbortSignal };
-
-//# sourceMappingURL=raceWithAbortSignal.js.map

package/dist/raceWithAbortSignal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"raceWithAbortSignal.js","names":[],"sources":["../src/raceWithAbortSignal.ts"],"sourcesContent":["const getAbortReason = (signal: AbortSignal): unknown => {\n  if (signal.reason !== undefined) return signal.reason;\n  const error = new Error(\"The operation was aborted\");\n  error.name = \"AbortError\";\n  return error;\n};\n\nexport const raceWithAbortSignal = <T>(\n  signal: AbortSignal | undefined,\n  operation: () => T | PromiseLike<T>,\n): Promise<T> => {\n  if (!signal) {\n    try {\n      return Promise.resolve(operation());\n    } catch (error) {\n      return Promise.reject(error);\n    }\n  }\n  if (signal.aborted) return Promise.reject(getAbortReason(signal));\n\n  return new Promise<T>((resolve, reject) => {\n    let settled = false;\n    const cleanup = () => signal.removeEventListener(\"abort\", handleAbort);\n    const resolveOnce = (value: T) => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      resolve(value);\n    };\n    const rejectOnce = (error: unknown) => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      reject(error);\n    };\n    const handleAbort = () => rejectOnce(getAbortReason(signal));\n\n    signal.addEventListener(\"abort\", handleAbort, { once: true });\n    let result: T | PromiseLike<T>;\n    try {\n      result = operation();\n    } catch (error) {\n      rejectOnce(error);\n      return;\n    }\n    Promise.resolve(result).then(resolveOnce, rejectOnce);\n  });\n};\n"],"mappings":";AAAA,MAAM,kBAAkB,WAAiC;CACvD,IAAI,OAAO,WAAW,KAAA,GAAW,OAAO,OAAO;CAC/C,MAAM,wBAAQ,IAAI,MAAM,2BAA2B;CACnD,MAAM,OAAO;CACb,OAAO;AACT;AAEA,MAAa,uBACX,QACA,cACe;CACf,IAAI,CAAC,QACH,IAAI;EACF,OAAO,QAAQ,QAAQ,UAAU,CAAC;CACpC,SAAS,OAAO;EACd,OAAO,QAAQ,OAAO,KAAK;CAC7B;CAEF,IAAI,OAAO,SAAS,OAAO,QAAQ,OAAO,eAAe,MAAM,CAAC;CAEhE,OAAO,IAAI,SAAY,SAAS,WAAW;EACzC,IAAI,UAAU;EACd,MAAM,gBAAgB,OAAO,oBAAoB,SAAS,WAAW;EACrE,MAAM,eAAe,UAAa;GAChC,IAAI,SAAS;GACb,UAAU;GACV,QAAQ;GACR,QAAQ,KAAK;EACf;EACA,MAAM,cAAc,UAAmB;GACrC,IAAI,SAAS;GACb,UAAU;GACV,QAAQ;GACR,OAAO,KAAK;EACd;EACA,MAAM,oBAAoB,WAAW,eAAe,MAAM,CAAC;EAE3D,OAAO,iBAAiB,SAAS,aAAa,EAAE,MAAM,KAAK,CAAC;EAC5D,IAAI;EACJ,IAAI;GACF,SAAS,UAAU;EACrB,SAAS,OAAO;GACd,WAAW,KAAK;GAChB;EACF;EACA,QAAQ,QAAQ,MAAM,CAAC,CAAC,KAAK,aAAa,UAAU;CACtD,CAAC;AACH"}

package/src/raceWithAbortSignal.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { raceWithAbortSignal } from "./raceWithAbortSignal";
-
-describe("raceWithAbortSignal", () => {
-  it("invokes the operation synchronously without a signal", async () => {
-    const order: string[] = [];
-
-    const result = raceWithAbortSignal(undefined, () => {
-      order.push("operation");
-      return "done";
-    });
-    order.push("after");
-
-    expect(order).toEqual(["operation", "after"]);
-    await expect(result).resolves.toBe("done");
-  });
-
-  it("converts a synchronous operation error to a rejection", async () => {
-    const error = new Error("failed");
-
-    const result = raceWithAbortSignal(undefined, () => {
-      throw error;
-    });
-
-    await expect(result).rejects.toBe(error);
-  });
-
-  it("rejects a pending operation with the abort reason", async () => {
-    const controller = new AbortController();
-    const reason = new Error("cancelled");
-    let resolveOperation!: (value: string) => void;
-    const operation = new Promise<string>((resolve) => {
-      resolveOperation = resolve;
-    });
-
-    const result = raceWithAbortSignal(controller.signal, () => operation);
-    controller.abort(reason);
-
-    await expect(result).rejects.toBe(reason);
-    resolveOperation("late result");
-  });
-
-  it("rejects before invoking an operation for an already aborted signal", async () => {
-    const controller = new AbortController();
-    const reason = new Error("already cancelled");
-    const operation = vi.fn(() => "done");
-    controller.abort(reason);
-
-    const result = raceWithAbortSignal(controller.signal, operation);
-
-    await expect(result).rejects.toBe(reason);
-    expect(operation).not.toHaveBeenCalled();
-  });
-
-  it("removes the abort listener after the operation settles", async () => {
-    const controller = new AbortController();
-    const removeEventListener = vi.spyOn(
-      controller.signal,
-      "removeEventListener",
-    );
-    const result = raceWithAbortSignal(controller.signal, () => "done");
-
-    await expect(result).resolves.toBe("done");
-    expect(removeEventListener).toHaveBeenCalledOnce();
-    expect(removeEventListener).toHaveBeenCalledWith(
-      "abort",
-      expect.any(Function),
-    );
-
-    controller.abort(new Error("late abort"));
-    await expect(result).resolves.toBe("done");
-  });
-});

package/src/raceWithAbortSignal.ts

@@ -1,48 +0,0 @@
-const getAbortReason = (signal: AbortSignal): unknown => {
-  if (signal.reason !== undefined) return signal.reason;
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  return error;
-};
-
-export const raceWithAbortSignal = <T>(
-  signal: AbortSignal | undefined,
-  operation: () => T | PromiseLike<T>,
-): Promise<T> => {
-  if (!signal) {
-    try {
-      return Promise.resolve(operation());
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  }
-  if (signal.aborted) return Promise.reject(getAbortReason(signal));
-
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const cleanup = () => signal.removeEventListener("abort", handleAbort);
-    const resolveOnce = (value: T) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(value);
-    };
-    const rejectOnce = (error: unknown) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      reject(error);
-    };
-    const handleAbort = () => rejectOnce(getAbortReason(signal));
-
-    signal.addEventListener("abort", handleAbort, { once: true });
-    let result: T | PromiseLike<T>;
-    try {
-      result = operation();
-    } catch (error) {
-      rejectOnce(error);
-      return;
-    }
-    Promise.resolve(result).then(resolveOnce, rejectOnce);
-  });
-};