@poolzin/pool-bot 2026.3.4 → 2026.3.6

package/dist/memory/embeddings.js

@@ -44,18 +44,34 @@ async function createLocalEmbeddingProvider(options) {
     let llama = null;
     let embeddingModel = null;
     let embeddingContext = null;
+    let initPromise = null;
     const ensureContext = async () => {
-        if (!llama) {
-            llama = await getLlama({ logLevel: LlamaLogLevel.error });
+        if (embeddingContext) {
+            return embeddingContext;
         }
-        if (!embeddingModel) {
-            const resolved = await resolveModelFile(modelPath, modelCacheDir || undefined);
-            embeddingModel = await llama.loadModel({ modelPath: resolved });
+        if (initPromise) {
+            return initPromise;
         }
-        if (!embeddingContext) {
-            embeddingContext = await embeddingModel.createEmbeddingContext();
-        }
-        return embeddingContext;
+        initPromise = (async () => {
+            try {
+                if (!llama) {
+                    llama = await getLlama({ logLevel: LlamaLogLevel.error });
+                }
+                if (!embeddingModel) {
+                    const resolved = await resolveModelFile(modelPath, modelCacheDir || undefined);
+                    embeddingModel = await llama.loadModel({ modelPath: resolved });
+                }
+                if (!embeddingContext) {
+                    embeddingContext = await embeddingModel.createEmbeddingContext();
+                }
+                return embeddingContext;
+            }
+            catch (err) {
+                initPromise = null;
+                throw err;
+            }
+        })();
+        return initPromise;
     };
     return {
         id: "local",

package/dist/memory/manager-embedding-ops.js

@@ -524,7 +524,7 @@ export class MemoryManagerEmbeddingOps extends MemoryManagerSyncOps {
             return;
         }
         const content = options.content ?? (await fs.readFile(entry.absPath, "utf-8"));
-        const chunks = enforceEmbeddingMaxInputTokens(this.provider, chunkMarkdown(content, this.settings.chunking).filter((chunk) => chunk.text.trim().length > 0));
+        const chunks = enforceEmbeddingMaxInputTokens(this.provider, chunkMarkdown(content, this.settings.chunking).filter((chunk) => chunk.text.trim().length > 0), EMBEDDING_BATCH_MAX_TOKENS);
         if (options.source === "sessions" && "lineMap" in entry) {
             remapChunkLines(chunks, entry.lineMap);
         }

package/dist/memory/post-json.js

@@ -0,0 +1,23 @@
+import { withRemoteHttpResponse } from "./remote-http.js";
+export async function postJson(params) {
+    return await withRemoteHttpResponse({
+        url: params.url,
+        ssrfPolicy: params.ssrfPolicy,
+        init: {
+            method: "POST",
+            headers: params.headers,
+            body: JSON.stringify(params.body),
+        },
+        onResponse: async (res) => {
+            if (!res.ok) {
+                const text = await res.text();
+                const err = new Error(`${params.errorPrefix}: ${res.status} ${text}`);
+                if (params.attachStatus) {
+                    err.status = res.status;
+                }
+                throw err;
+            }
+            return await params.parse(await res.json());
+        },
+    });
+}

package/dist/memory/qmd-manager.js

@@ -5,12 +5,15 @@ import path from "node:path";
 import readline from "node:readline";
 import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
 import { resolveStateDir } from "../config/paths.js";
+import { writeFileWithinRoot } from "../infra/fs-safe.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
+import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram, } from "../plugin-sdk/windows-spawn.js";
 import { isFileMissingError, statRegularFile } from "./fs-utils.js";
 import { deriveQmdScopeChannel, deriveQmdScopeChatType, isQmdScopeAllowed } from "./qmd-scope.js";
 import { listSessionFilesForAgent, buildSessionEntry, } from "./session-files.js";
 import { requireNodeSqlite } from "./sqlite.js";
 import { parseQmdQueryJson } from "./qmd-query-parser.js";
+import { extractKeywords } from "./query-expansion.js";
 const log = createSubsystemLogger("memory");
 const SNIPPET_HEADER_RE = /@@\s*-([0-9]+),([0-9]+)/;
 const SEARCH_PENDING_UPDATE_WAIT_MS = 500;
@@ -18,7 +21,70 @@ const MAX_QMD_OUTPUT_CHARS = 200_000;
 const NUL_MARKER_RE = /(?:\^@|\\0|\\x00|\\u0000|null\s*byte|nul\s*byte)/i;
 const QMD_EMBED_BACKOFF_BASE_MS = 60_000;
 const QMD_EMBED_BACKOFF_MAX_MS = 60 * 60 * 1000;
+const HAN_SCRIPT_RE = /[\u3400-\u9fff]/u;
+const QMD_BM25_HAN_KEYWORD_LIMIT = 12;
 let qmdEmbedQueueTail = Promise.resolve();
+function resolveWindowsCommandShim(command) {
+    if (process.platform !== "win32") {
+        return command;
+    }
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return command;
+    }
+    const ext = path.extname(trimmed).toLowerCase();
+    if (ext === ".cmd" || ext === ".exe" || ext === ".bat") {
+        return command;
+    }
+    const base = path.basename(trimmed).toLowerCase();
+    if (base === "qmd" || base === "mcporter") {
+        return `${trimmed}.cmd`;
+    }
+    return command;
+}
+function resolveSpawnInvocation(params) {
+    const program = resolveWindowsSpawnProgram({
+        command: resolveWindowsCommandShim(params.command),
+        platform: process.platform,
+        env: params.env,
+        execPath: process.execPath,
+        packageName: params.packageName,
+        allowShellFallback: true,
+    });
+    return materializeWindowsSpawnProgram(program, params.args);
+}
+function hasHanScript(value) {
+    return HAN_SCRIPT_RE.test(value);
+}
+function normalizeHanBm25Query(query) {
+    const trimmed = query.trim();
+    if (!trimmed || !hasHanScript(trimmed)) {
+        return trimmed;
+    }
+    const keywords = extractKeywords(trimmed);
+    const normalizedKeywords = [];
+    const seen = new Set();
+    for (const keyword of keywords) {
+        const token = keyword.trim();
+        if (!token || seen.has(token)) {
+            continue;
+        }
+        const includesHan = hasHanScript(token);
+        // Han unigrams are usually too broad for BM25 and can drown signal.
+        if (includesHan && Array.from(token).length < 2) {
+            continue;
+        }
+        if (!includesHan && token.length < 2) {
+            continue;
+        }
+        seen.add(token);
+        normalizedKeywords.push(token);
+        if (normalizedKeywords.length >= QMD_BM25_HAN_KEYWORD_LIMIT) {
+            break;
+        }
+    }
+    return normalizedKeywords.length > 0 ? normalizedKeywords.join(" ") : trimmed;
+}
 async function runWithQmdEmbedLock(task) {
     const previous = qmdEmbedQueueTail;
     let release;
@@ -54,6 +120,7 @@ export class QmdMemoryManager {
     xdgCacheHome;
     indexPath;
     env;
+    managedCollectionNames;
     collectionRoots = new Map();
     sources = new Set();
     docPathCache = new Map();
@@ -89,6 +156,9 @@ export class QmdMemoryManager {
         this.env = {
             ...process.env,
             XDG_CONFIG_HOME: this.xdgConfigHome,
+            // workaround for upstream bug https://github.com/tobi/qmd/issues/132
+            // QMD doesn't respect XDG_CONFIG_HOME:
+            QMD_CONFIG_DIR: this.xdgConfigHome,
             XDG_CACHE_HOME: this.xdgCacheHome,
             NO_COLOR: "1",
         };
@@ -112,6 +182,7 @@ export class QmdMemoryManager {
                 },
             ];
         }
+        this.managedCollectionNames = this.computeManagedCollectionNames();
     }
     async initialize(mode) {
         this.bootstrapCollections();
@@ -171,29 +242,9 @@ export class QmdMemoryManager {
             const result = await this.runQmd(["collection", "list", "--json"], {
                 timeoutMs: this.qmd.update.commandTimeoutMs,
             });
-            const parsed = JSON.parse(result.stdout);
-            if (Array.isArray(parsed)) {
-                for (const entry of parsed) {
-                    if (typeof entry === "string") {
-                        existing.set(entry, {});
-                    }
-                    else if (entry && typeof entry === "object") {
-                        const name = entry.name;
-                        if (typeof name === "string") {
-                            const listedPath = entry.path;
-                            const listedPattern = entry.pattern;
-                            const listedMask = entry.mask;
-                            existing.set(name, {
-                                path: typeof listedPath === "string" ? listedPath : undefined,
-                                pattern: typeof listedPattern === "string"
-                                    ? listedPattern
-                                    : typeof listedMask === "string"
-                                        ? listedMask
-                                        : undefined,
-                            });
-                        }
-                    }
-                }
+            const parsed = this.parseListedCollections(result.stdout);
+            for (const [name, details] of parsed) {
+                existing.set(name, details);
             }
         }
         catch {
@@ -292,6 +343,18 @@ export class QmdMemoryManager {
         const lower = message.toLowerCase();
         return (lower.includes("not found") || lower.includes("does not exist") || lower.includes("missing"));
     }
+    isMissingCollectionSearchError(err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return this.isCollectionMissingError(message) && message.toLowerCase().includes("collection");
+    }
+    async tryRepairMissingCollectionSearch(err) {
+        if (!this.isMissingCollectionSearchError(err)) {
+            return false;
+        }
+        log.warn("qmd search failed because a managed collection is missing; repairing collections and retrying once");
+        await this.ensureCollections();
+        return true;
+    }
     async addCollection(pathArg, name, pattern) {
         await this.runQmd(["collection", "add", pathArg, "--name", name, "--mask", pattern], {
             timeoutMs: this.qmd.update.commandTimeoutMs,
@@ -302,6 +365,90 @@ export class QmdMemoryManager {
             timeoutMs: this.qmd.update.commandTimeoutMs,
         });
     }
+    parseListedCollections(output) {
+        const listed = new Map();
+        const trimmed = output.trim();
+        if (!trimmed) {
+            return listed;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                for (const entry of parsed) {
+                    if (typeof entry === "string") {
+                        listed.set(entry, {});
+                        continue;
+                    }
+                    if (!entry || typeof entry !== "object") {
+                        continue;
+                    }
+                    const name = entry.name;
+                    if (typeof name !== "string") {
+                        continue;
+                    }
+                    const listedPath = entry.path;
+                    const listedPattern = entry.pattern;
+                    const listedMask = entry.mask;
+                    listed.set(name, {
+                        path: typeof listedPath === "string" ? listedPath : undefined,
+                        pattern: typeof listedPattern === "string"
+                            ? listedPattern
+                            : typeof listedMask === "string"
+                                ? listedMask
+                                : undefined,
+                    });
+                }
+                return listed;
+            }
+        }
+        catch {
+            // Some qmd builds ignore `--json` and still print table output.
+        }
+        let currentName = null;
+        for (const rawLine of output.split(/\r?\n/)) {
+            const line = rawLine.trimEnd();
+            if (!line.trim()) {
+                currentName = null;
+                continue;
+            }
+            const collectionLine = /^\s*([a-z0-9._-]+)\s+\(qmd:\/\/[^)]+\)\s*$/i.exec(line);
+            if (collectionLine) {
+                currentName = collectionLine[1];
+                if (!listed.has(currentName)) {
+                    listed.set(currentName, {});
+                }
+                continue;
+            }
+            if (/^\s*collections\b/i.test(line)) {
+                continue;
+            }
+            const bareNameLine = /^\s*([a-z0-9._-]+)\s*$/i.exec(line);
+            if (bareNameLine && !line.includes(":")) {
+                currentName = bareNameLine[1];
+                if (!listed.has(currentName)) {
+                    listed.set(currentName, {});
+                }
+                continue;
+            }
+            if (!currentName) {
+                continue;
+            }
+            const patternLine = /^\s*(?:pattern|mask)\s*:\s*(.+?)\s*$/i.exec(line);
+            if (patternLine) {
+                const existing = listed.get(currentName) ?? {};
+                existing.pattern = patternLine[1].trim();
+                listed.set(currentName, existing);
+                continue;
+            }
+            const pathLine = /^\s*path\s*:\s*(.+?)\s*$/i.exec(line);
+            if (pathLine) {
+                const existing = listed.get(currentName) ?? {};
+                existing.path = pathLine[1].trim();
+                listed.set(currentName, existing);
+            }
+        }
+        return listed;
+    }
     shouldRebindCollection(collection, listed) {
         if (!listed.path) {
             // Older qmd versions may only return names from `collection list --json`.
@@ -381,26 +528,25 @@ export class QmdMemoryManager {
         }
         const qmdSearchCommand = this.qmd.searchMode;
         const mcporterEnabled = this.qmd.mcporter.enabled;
-        let parsed;
-        try {
-            if (mcporterEnabled) {
-                const tool = qmdSearchCommand === "search"
-                    ? "search"
-                    : qmdSearchCommand === "vsearch"
-                        ? "vector_search"
-                        : "deep_search";
-                const minScore = opts?.minScore ?? 0;
-                if (collectionNames.length > 1) {
-                    parsed = await this.runMcporterAcrossCollections({
-                        tool,
-                        query: trimmed,
-                        limit,
-                        minScore,
-                        collectionNames,
-                    });
-                }
-                else {
-                    parsed = await this.runQmdSearchViaMcporter({
+        const runSearchAttempt = async (allowMissingCollectionRepair) => {
+            try {
+                if (mcporterEnabled) {
+                    const tool = qmdSearchCommand === "search"
+                        ? "search"
+                        : qmdSearchCommand === "vsearch"
+                            ? "vector_search"
+                            : "deep_search";
+                    const minScore = opts?.minScore ?? 0;
+                    if (collectionNames.length > 1) {
+                        return await this.runMcporterAcrossCollections({
+                            tool,
+                            query: trimmed,
+                            limit,
+                            minScore,
+                            collectionNames,
+                        });
+                    }
+                    return await this.runQmdSearchViaMcporter({
                         mcporter: this.qmd.mcporter,
                         tool,
                         query: trimmed,
@@ -410,47 +556,54 @@ export class QmdMemoryManager {
                         timeoutMs: this.qmd.limits.timeoutMs,
                     });
                 }
-            }
-            else if (collectionNames.length > 1) {
-                parsed = await this.runQueryAcrossCollections(trimmed, limit, collectionNames, qmdSearchCommand);
-            }
-            else {
+                if (collectionNames.length > 1) {
+                    return await this.runQueryAcrossCollections(trimmed, limit, collectionNames, qmdSearchCommand);
+                }
                 const args = this.buildSearchArgs(qmdSearchCommand, trimmed, limit);
                 args.push(...this.buildCollectionFilterArgs(collectionNames));
                 // Always scope to managed collections (default + custom). Even for `search`/`vsearch`,
                 // pass collection filters; if a given QMD build rejects these flags, we fall back to `query`.
                 const result = await this.runQmd(args, { timeoutMs: this.qmd.limits.timeoutMs });
-                parsed = parseQmdQueryJson(result.stdout, result.stderr);
+                return parseQmdQueryJson(result.stdout, result.stderr);
             }
-        }
-        catch (err) {
-            if (!mcporterEnabled &&
-                qmdSearchCommand !== "query" &&
-                this.isUnsupportedQmdOptionError(err)) {
-                log.warn(`qmd ${qmdSearchCommand} does not support configured flags; retrying search with qmd query`);
-                try {
-                    if (collectionNames.length > 1) {
-                        parsed = await this.runQueryAcrossCollections(trimmed, limit, collectionNames, "query");
-                    }
-                    else {
+            catch (err) {
+                if (allowMissingCollectionRepair && this.isMissingCollectionSearchError(err)) {
+                    throw err;
+                }
+                if (!mcporterEnabled &&
+                    qmdSearchCommand !== "query" &&
+                    this.isUnsupportedQmdOptionError(err)) {
+                    log.warn(`qmd ${qmdSearchCommand} does not support configured flags; retrying search with qmd query`);
+                    try {
+                        if (collectionNames.length > 1) {
+                            return await this.runQueryAcrossCollections(trimmed, limit, collectionNames, "query");
+                        }
                         const fallbackArgs = this.buildSearchArgs("query", trimmed, limit);
                         fallbackArgs.push(...this.buildCollectionFilterArgs(collectionNames));
                         const fallback = await this.runQmd(fallbackArgs, {
                             timeoutMs: this.qmd.limits.timeoutMs,
                         });
-                        parsed = parseQmdQueryJson(fallback.stdout, fallback.stderr);
+                        return parseQmdQueryJson(fallback.stdout, fallback.stderr);
+                    }
+                    catch (fallbackErr) {
+                        log.warn(`qmd query fallback failed: ${String(fallbackErr)}`);
+                        throw fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr));
                     }
                 }
-                catch (fallbackErr) {
-                    log.warn(`qmd query fallback failed: ${String(fallbackErr)}`);
-                    throw fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr));
-                }
-            }
-            else {
                 const label = mcporterEnabled ? "mcporter/qmd" : `qmd ${qmdSearchCommand}`;
                 log.warn(`${label} failed: ${String(err)}`);
                 throw err instanceof Error ? err : new Error(String(err));
             }
+        };
+        let parsed;
+        try {
+            parsed = await runSearchAttempt(true);
+        }
+        catch (err) {
+            if (!(await this.tryRepairMissingCollectionSearch(err))) {
+                throw err instanceof Error ? err : new Error(String(err));
+            }
+            parsed = await runSearchAttempt(false);
         }
         const results = [];
         for (const entry of parsed) {
@@ -603,7 +756,10 @@ export class QmdMemoryManager {
             if (this.shouldRunEmbed(force)) {
                 try {
                     await runWithQmdEmbedLock(async () => {
-                        await this.runQmd(["embed"], { timeoutMs: this.qmd.update.embedTimeoutMs });
+                        await this.runQmd(["embed"], {
+                            timeoutMs: this.qmd.update.embedTimeoutMs,
+                            discardOutput: true,
+                        });
                     });
                     this.lastEmbedAt = Date.now();
                     this.embedBackoffUntil = null;
@@ -641,13 +797,19 @@ export class QmdMemoryManager {
     }
     async runQmdUpdateOnce(reason) {
         try {
-            await this.runQmd(["update"], { timeoutMs: this.qmd.update.updateTimeoutMs });
+            await this.runQmd(["update"], {
+                timeoutMs: this.qmd.update.updateTimeoutMs,
+                discardOutput: true,
+            });
         }
         catch (err) {
             if (!(await this.tryRepairNullByteCollections(err, reason))) {
                 throw err;
             }
-            await this.runQmd(["update"], { timeoutMs: this.qmd.update.updateTimeoutMs });
+            await this.runQmd(["update"], {
+                timeoutMs: this.qmd.update.updateTimeoutMs,
+                discardOutput: true,
+            });
         }
     }
     isRetryableUpdateError(err) {
@@ -759,14 +921,26 @@ export class QmdMemoryManager {
     }
     async runQmd(args, opts) {
         return await new Promise((resolve, reject) => {
-            const child = spawn(this.qmd.command, args, {
+            const spawnInvocation = resolveSpawnInvocation({
+                command: this.qmd.command,
+                args,
+                env: this.env,
+                packageName: "qmd",
+            });
+            const child = spawn(spawnInvocation.command, spawnInvocation.argv, {
                 env: this.env,
                 cwd: this.workspaceDir,
+                shell: spawnInvocation.shell,
+                windowsHide: spawnInvocation.windowsHide,
             });
             let stdout = "";
             let stderr = "";
             let stdoutTruncated = false;
             let stderrTruncated = false;
+            // When discardOutput is set, skip stdout accumulation entirely and keep
+            // only a small stderr tail for diagnostics -- never fail on truncation.
+            // This prevents large `qmd update` runs from hitting the output cap.
+            const discard = opts?.discardOutput === true;
             const timer = opts?.timeoutMs
                 ? setTimeout(() => {
                     child.kill("SIGKILL");
@@ -774,6 +948,9 @@ export class QmdMemoryManager {
                 }, opts.timeoutMs)
                 : null;
             child.stdout.on("data", (data) => {
+                if (discard) {
+                    return; // drain without accumulating
+                }
                 const next = appendOutputWithCap(stdout, data.toString("utf8"), this.maxQmdOutputChars);
                 stdout = next.text;
                 stdoutTruncated = stdoutTruncated || next.truncated;
@@ -793,7 +970,7 @@ export class QmdMemoryManager {
                 if (timer) {
                     clearTimeout(timer);
                 }
-                if (stdoutTruncated || stderrTruncated) {
+                if (!discard && (stdoutTruncated || stderrTruncated)) {
                     reject(new Error(`qmd ${args.join(" ")} produced too much output (limit ${this.maxQmdOutputChars} chars)`));
                     return;
                 }
@@ -835,10 +1012,18 @@ export class QmdMemoryManager {
     }
     async runMcporter(args, opts) {
         return await new Promise((resolve, reject) => {
-            const child = spawn("mcporter", args, {
+            const spawnInvocation = resolveSpawnInvocation({
+                command: "mcporter",
+                args,
+                env: this.env,
+                packageName: "mcporter",
+            });
+            const child = spawn(spawnInvocation.command, spawnInvocation.argv, {
                 // Keep mcporter and direct qmd commands on the same agent-scoped XDG state.
                 env: this.env,
                 cwd: this.workspaceDir,
+                shell: spawnInvocation.shell,
+                windowsHide: spawnInvocation.windowsHide,
             });
             let stdout = "";
             let stderr = "";
@@ -1011,11 +1196,17 @@ export class QmdMemoryManager {
             if (cutoff && entry.mtimeMs < cutoff) {
                 continue;
             }
-            const target = path.join(exportDir, `${path.basename(sessionFile, ".jsonl")}.md`);
+            const targetName = `${path.basename(sessionFile, ".jsonl")}.md`;
+            const target = path.join(exportDir, targetName);
             tracked.add(sessionFile);
             const state = this.exportedSessionState.get(sessionFile);
             if (!state || state.hash !== entry.hash || state.mtimeMs !== entry.mtimeMs) {
-                await fs.writeFile(target, this.renderSessionMarkdown(entry), "utf-8");
+                await writeFileWithinRoot({
+                    rootDir: exportDir,
+                    relativePath: targetName,
+                    data: this.renderSessionMarkdown(entry),
+                    encoding: "utf-8",
+                });
             }
             this.exportedSessionState.set(sessionFile, {
                 hash: entry.hash,
@@ -1439,6 +1630,9 @@ export class QmdMemoryManager {
         return [...bestByDocId.values()].toSorted((a, b) => (b.score ?? 0) - (a.score ?? 0));
     }
     listManagedCollectionNames() {
+        return this.managedCollectionNames;
+    }
+    computeManagedCollectionNames() {
         const seen = new Set();
         const names = [];
         for (const collection of this.qmd.collections) {
@@ -1459,10 +1653,11 @@ export class QmdMemoryManager {
         return names.flatMap((name) => ["-c", name]);
     }
     buildSearchArgs(command, query, limit) {
+        const normalizedQuery = command === "search" ? normalizeHanBm25Query(query) : query;
         if (command === "query") {
-            return ["query", query, "--json", "-n", String(limit)];
+            return ["query", normalizedQuery, "--json", "-n", String(limit)];
         }
-        return [command, query, "--json", "-n", String(limit)];
+        return [command, normalizedQuery, "--json", "-n", String(limit)];
     }
 }
 function appendOutputWithCap(current, chunk, maxChars) {

package/dist/memory/remote-http.js

@@ -0,0 +1,33 @@
+import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
+export function buildRemoteBaseUrlPolicy(baseUrl) {
+    const trimmed = baseUrl.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return undefined;
+        }
+        // Keep policy tied to the configured host so private operator endpoints
+        // continue to work, while cross-host redirects stay blocked.
+        return { allowedHostnames: [parsed.hostname] };
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function withRemoteHttpResponse(params) {
+    const { response, release } = await fetchWithSsrFGuard({
+        url: params.url,
+        init: params.init,
+        policy: params.ssrfPolicy,
+        auditContext: params.auditContext ?? "memory-remote",
+    });
+    try {
+        return await params.onResponse(response);
+    }
+    finally {
+        await release();
+    }
+}