recallnest 3.0.0 → 4.0.0

package/src/__tests__/llm-client-pivot.test.ts

@@ -1,628 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { LLMClient } from "../llm-client.js";
-import {
-  buildPivotLlmConfig,
-  buildPivotRequestProfile,
-  buildStratifiedSample,
-  loadFrozenBundle,
-  main as pivotMain,
-  PIPELINE_VERSION,
-  PIVOT_MODEL,
-  pivotRequestProfileHash,
-  PROMPT_VERSION,
-  selectionIdentityHash,
-  writeFrozenBundle,
-  type SessionMeta,
-} from "../../scripts/pivot-distill.js";
-
-interface CapturedRequest {
-  method: string;
-  url: string;
-  body: unknown;
-}
-
-interface LoopbackStub {
-  baseURL: string;
-  requests: CapturedRequest[];
-  close: () => Promise<void>;
-}
-
-interface PlannedResponse {
-  body: Record<string, unknown>;
-  statusCode?: number;
-  headers?: Record<string, string>;
-}
-
-async function startLoopbackStub(
-  responseBody: Record<string, unknown> | PlannedResponse[],
-  statusCode = 200,
-  responseHeaders: Record<string, string> = {},
-): Promise<LoopbackStub> {
-  const requests: CapturedRequest[] = [];
-  const server = createServer(async (request, response) => {
-    try {
-      const chunks: Buffer[] = [];
-      for await (const chunk of request) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-      }
-      const body: unknown = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-      requests.push({
-        method: request.method ?? "",
-        url: request.url ?? "",
-        body,
-      });
-      const planned = Array.isArray(responseBody)
-        ? responseBody[Math.min(requests.length - 1, responseBody.length - 1)]
-        : { body: responseBody, statusCode, headers: responseHeaders };
-      response.writeHead(planned.statusCode ?? 200, {
-        "content-type": "application/json",
-        connection: "close",
-        ...(planned.headers ?? {}),
-      });
-      response.end(JSON.stringify(planned.body));
-    } catch (error) {
-      response.writeHead(500, { "content-type": "text/plain", connection: "close" });
-      response.end(error instanceof Error ? error.message : "loopback stub error");
-    }
-  });
-  await new Promise<void>((resolve, reject) => {
-    const onError = (error: Error): void => reject(error);
-    server.once("error", onError);
-    server.listen(0, "127.0.0.1", () => {
-      server.off("error", onError);
-      resolve();
-    });
-  });
-  const address = server.address();
-  if (!address || typeof address === "string") {
-    server.close();
-    throw new Error("Loopback stub did not receive a TCP address");
-  }
-
-  return {
-    baseURL: `http://127.0.0.1:${address.port}/v1`,
-    requests,
-    close: async () => {
-      await new Promise<void>((resolve, reject) => {
-        server.close((error) => error ? reject(error) : resolve());
-        server.closeAllConnections();
-      });
-    },
-  };
-}
-
-function completionResponse(options: {
-  content: string | null;
-  finishReason: "stop" | "length";
-  model: string;
-  usage?: Record<string, unknown>;
-}): Record<string, unknown> {
-  return {
-    id: "chatcmpl-loopback",
-    object: "chat.completion",
-    created: 0,
-    model: options.model,
-    choices: [{
-      index: 0,
-      message: { role: "assistant", content: options.content },
-      logprobs: null,
-      finish_reason: options.finishReason,
-    }],
-    ...(options.usage ? { usage: options.usage } : {}),
-  };
-}
-
-describe("LLMClient pivot detailed chat", () => {
-  it("sends the exact Qwen-compatible request body and returns normalized metadata", async () => {
-    const stub = await startLoopbackStub(completionResponse({
-      content: "  {\"ok\":true}  ",
-      finishReason: "stop",
-      model: "qwen-response-snapshot",
-      usage: {
-        prompt_tokens: 120,
-        completion_tokens: 18,
-        total_tokens: 138,
-        prompt_tokens_details: { cached_tokens: 12 },
-        completion_tokens_details: { reasoning_tokens: 3 },
-      },
-    }));
-    try {
-      const unsafeBaseURL = stub.baseURL.replace("http://", "http://user:password@") +
-        "?token=secret#fragment";
-      const profile = buildPivotRequestProfile(unsafeBaseURL);
-      const client = new LLMClient(buildPivotLlmConfig({
-        apiKey: "loopback-test-key",
-        model: "qwen-request-snapshot",
-        baseURL: unsafeBaseURL,
-      }, profile, 1_000));
-
-      const result = await client.chatLongDetailed("system prompt", "user prompt", {
-        temperature: 0.05,
-        enableThinking: false,
-        responseFormat: { type: "json_object" },
-        tokenLimit: { parameter: "max_tokens", value: 321 },
-      });
-
-      expect(stub.requests).toHaveLength(1);
-      expect(stub.requests[0]).toEqual({
-        method: "POST",
-        url: "/v1/chat/completions",
-        body: {
-          model: PIVOT_MODEL,
-          messages: [
-            { role: "system", content: "system prompt" },
-            { role: "user", content: "user prompt" },
-          ],
-          temperature: 0.05,
-          max_tokens: 321,
-          response_format: { type: "json_object" },
-          enable_thinking: false,
-        },
-      });
-      expect(result).toEqual({
-        content: "{\"ok\":true}",
-        finishReason: "stop",
-        responseModel: "qwen-response-snapshot",
-        usage: {
-          promptTokens: 120,
-          completionTokens: 18,
-          totalTokens: 138,
-          cachedPromptTokens: 12,
-          reasoningTokens: 3,
-        },
-      });
-    } finally {
-      await stub.close();
-    }
-  });
-
-  it("disables hidden SDK retries so one outer attempt sends one HTTP request", async () => {
-    const stub = await startLoopbackStub({
-      error: { message: "temporary failure", type: "server_error" },
-    }, 500, { "retry-after": "0" });
-    try {
-      const client = new LLMClient({
-        apiKey: "loopback-test-key",
-        model: "qwen-request-snapshot",
-        baseURL: stub.baseURL,
-        timeoutMs: 1_000,
-        maxRetries: 0,
-      });
-      await expect(client.chatLongDetailed("system", "user")).rejects.toThrow();
-      expect(stub.requests).toHaveLength(1);
-    } finally {
-      await stub.close();
-    }
-  });
-
-  it("supports max_completion_tokens and exposes a length finish reason", async () => {
-    const stub = await startLoopbackStub(completionResponse({
-      content: "{\"partial\":true}",
-      finishReason: "length",
-      model: "qwen-response-snapshot",
-    }));
-    try {
-      const client = new LLMClient({
-        apiKey: "loopback-test-key",
-        model: "qwen-request-snapshot",
-        baseURL: stub.baseURL,
-        timeoutMs: 1_000,
-      });
-
-      const result = await client.chatLongDetailed("system", "user", {
-        tokenLimit: { parameter: "max_completion_tokens", value: 456 },
-      });
-
-      expect(stub.requests[0].body).toEqual({
-        model: "qwen-request-snapshot",
-        messages: [
-          { role: "system", content: "system" },
-          { role: "user", content: "user" },
-        ],
-        temperature: 0.1,
-        max_completion_tokens: 456,
-      });
-      expect(result).toEqual({
-        content: "{\"partial\":true}",
-        finishReason: "length",
-        responseModel: "qwen-response-snapshot",
-        usage: null,
-      });
-    } finally {
-      await stub.close();
-    }
-  });
-
-  it("keeps chatLong as a string-or-null max_tokens wrapper", async () => {
-    const stub = await startLoopbackStub(completionResponse({
-      content: "  legacy content  ",
-      finishReason: "stop",
-      model: "legacy-response-model",
-    }));
-    try {
-      const client = new LLMClient({
-        apiKey: "loopback-test-key",
-        model: "legacy-request-model",
-        baseURL: stub.baseURL,
-        timeoutMs: 1_000,
-        temperature: 0.25,
-      });
-
-      const result: string | null = await client.chatLong("legacy system", "legacy user", 77);
-
-      expect(result).toBe("legacy content");
-      expect(stub.requests[0].body).toEqual({
-        model: "legacy-request-model",
-        messages: [
-          { role: "system", content: "legacy system" },
-          { role: "user", content: "legacy user" },
-        ],
-        temperature: 0.25,
-        max_tokens: 77,
-      });
-    } finally {
-      await stub.close();
-    }
-  });
-
-  it("runs authorized transport only from the frozen bundle with bounded retries and complete audit identity", async () => {
-    const invalidUsage = { prompt_tokens: 10, completion_tokens: 2, total_tokens: 12 };
-    const successUsage = { prompt_tokens: 11, completion_tokens: 3, total_tokens: 14 };
-    const success = completionResponse({
-      content: JSON.stringify({ hasPivot: false, candidates: [] }),
-      finishReason: "stop",
-      model: PIVOT_MODEL,
-      usage: successUsage,
-    });
-    const stub = await startLoopbackStub([
-      {
-        statusCode: 429,
-        headers: { "retry-after": "0" },
-        body: { error: { message: "rate limited", type: "rate_limit_error" } },
-      },
-      {
-        body: completionResponse({
-          content: "not-json",
-          finishReason: "stop",
-          model: PIVOT_MODEL,
-          usage: invalidUsage,
-        }),
-      },
-      { body: success },
-    ]);
-    const root = mkdtempSync(join(tmpdir(), "pivot-transport-loopback-"));
-    const sourcePath = join(root, "source.jsonl");
-    writeFileSync(sourcePath, "{}\n");
-    const sourceStat = statSync(sourcePath, { bigint: true });
-    const profile = buildPivotRequestProfile(stub.baseURL, 600);
-    const descriptor = writeFrozenBundle(root, [{
-      session: {
-        key: "codex:loopback-session",
-        sessionId: "loopback-session",
-        rawHarness: "codex",
-        harness: "codex",
-        parserKind: "codex-rollout",
-        project: "test",
-        path: sourcePath,
-        date: "2026-08-03",
-        sizeBytes: Number(sourceStat.size),
-        mtimeNs: sourceStat.mtimeNs.toString(),
-        origin: "deja",
-        fingerprint: "placeholder",
-      } satisfies SessionMeta,
-      sample: buildStratifiedSample([
-        { role: "user", text: "请保留可以回查的出处" },
-        { role: "assistant", text: "已经记录出处" },
-      ], 600),
-    }], profile, pivotRequestProfileHash(profile));
-    const bundleDir = join(root, "input-bundle");
-    const loaded = loadFrozenBundle(bundleDir, descriptor.bundleHash, descriptor.requestProfileHash);
-    const entry = loaded.entries[0];
-    const configPath = join(root, "config.json");
-    writeFileSync(configPath, JSON.stringify({
-      llm: { apiKey: "loopback-test-key", model: "qwen-turbo", baseURL: stub.baseURL },
-    }));
-    const outputDir = join(root, "transport-output");
-    mkdirSync(outputDir, { mode: 0o755 });
-    const dejaMarker = join(root, "deja-was-called");
-    const fakeDeja = join(root, "must-not-run-deja.sh");
-    writeFileSync(fakeDeja, `#!/bin/sh\ntouch "${dejaMarker}"\nexit 99\n`, { mode: 0o700 });
-    chmodSync(fakeDeja, 0o700);
-    const args = [
-      "--mode", "transport",
-      "--input-bundle", bundleDir,
-      "--bundle-hash", descriptor.bundleHash,
-      "--request-profile-hash", descriptor.requestProfileHash,
-      "--session-key", entry.session.key,
-      "--output-dir", outputDir,
-      "--deja-bin", fakeDeja,
-      "--allow-external-llm",
-    ];
-    const previousConfig = process.env.LOCAL_MEMORY_CONFIG;
-    process.env.LOCAL_MEMORY_CONFIG = configPath;
-    try {
-      await pivotMain(args);
-      expect(stub.requests).toHaveLength(3);
-      expect(stub.requests.every((request) => request.url === "/v1/chat/completions")).toBe(true);
-      expect(existsSync(dejaMarker)).toBe(false);
-      const resultPath = join(outputDir, "results", `${entry.session.fingerprint}.json`);
-      const result = JSON.parse(readFileSync(resultPath, "utf8")) as {
-        mode: string;
-        selectionHash: string;
-        outboundSampleSha256: string;
-        status: string;
-        attempts: number;
-        responseModel: string;
-        usage: { promptTokens: number; completionTokens: number; totalTokens: number };
-        attemptErrors: string[];
-      };
-      expect(result).toMatchObject({
-        mode: "transport",
-        outboundSampleSha256: entry.sampleSha256,
-        status: "ok",
-        attempts: 3,
-        responseModel: PIVOT_MODEL,
-        usage: { promptTokens: 21, completionTokens: 5, totalTokens: 26 },
-      });
-      expect(result.selectionHash).toHaveLength(64);
-      expect(result.attemptErrors).toHaveLength(2);
-      const invalid = JSON.parse(
-        readFileSync(join(outputDir, "invalid", `${entry.session.fingerprint}.json`), "utf8"),
-      ) as { attempts: Array<{ usage?: { promptTokens: number; completionTokens: number; totalTokens: number } }> };
-      expect(invalid.attempts).toHaveLength(2);
-      expect(invalid.attempts[1].usage).toEqual({
-        promptTokens: 10, completionTokens: 2, totalTokens: 12,
-      });
-      const summary = JSON.parse(readFileSync(join(outputDir, "summary.json"), "utf8")) as Record<string, unknown>;
-      const reportState = JSON.parse(
-        readFileSync(join(outputDir, "report-state.json"), "utf8"),
-      ) as Record<string, unknown>;
-      expect(summary).toMatchObject({
-        reportStatus: "complete",
-        mode: "transport",
-        selectionHash: result.selectionHash,
-        manifestSessions: 1,
-        resultSessions: 1,
-        usage: { promptTokens: 21, completionTokens: 5, totalTokens: 26 },
-        attemptAudit: {
-          validLedgers: 1,
-          invalidLedgers: 0,
-          startedAttempts: 3,
-          inFlightAttempts: 0,
-          recordedUsage: { promptTokens: 21, completionTokens: 5, totalTokens: 26 },
-        },
-      });
-      expect(reportState).toMatchObject({
-        status: "complete", mode: "transport", selectionHash: result.selectionHash,
-      });
-      expect(statSync(outputDir).mode & 0o777).toBe(0o700);
-      expect(statSync(join(outputDir, "results")).mode & 0o777).toBe(0o700);
-      expect(statSync(join(outputDir, "attempts")).mode & 0o777).toBe(0o700);
-      expect(statSync(resultPath).mode & 0o777).toBe(0o600);
-      expect(statSync(join(outputDir, "attempts", `${entry.session.fingerprint}.json`)).mode & 0o777)
-        .toBe(0o600);
-      expect(statSync(join(outputDir, "summary.json")).mode & 0o777).toBe(0o600);
-
-      await pivotMain(args);
-      expect(stub.requests).toHaveLength(3);
-      result.responseModel = "tampered-model";
-      writeFileSync(resultPath, `${JSON.stringify(result)}\n`);
-      await expect(pivotMain(args)).rejects.toThrow("failed strict identity validation");
-      expect(stub.requests).toHaveLength(3);
-      expect(JSON.parse(readFileSync(join(outputDir, "report-state.json"), "utf8")))
-        .toMatchObject({ status: "partial" });
-      expect(JSON.parse(readFileSync(join(outputDir, "summary.json"), "utf8")))
-        .toMatchObject({ reportStatus: "partial", resultSessions: 0 });
-    } finally {
-      if (previousConfig === undefined) delete process.env.LOCAL_MEMORY_CONFIG;
-      else process.env.LOCAL_MEMORY_CONFIG = previousConfig;
-      await stub.close();
-    }
-  }, 15_000);
-
-  it("preserves empty-content usage and refuses to reset a failed run's three-attempt budget", async () => {
-    const usage = [
-      { prompt_tokens: 4, completion_tokens: 1, total_tokens: 5 },
-      { prompt_tokens: 5, completion_tokens: 2, total_tokens: 7 },
-      { prompt_tokens: 6, completion_tokens: 3, total_tokens: 9 },
-    ];
-    const stub = await startLoopbackStub(usage.map((attemptUsage, index) => ({
-      body: completionResponse({
-        content: index === 0 ? null : "not-json",
-        finishReason: "stop",
-        model: PIVOT_MODEL,
-        usage: attemptUsage,
-      }),
-    })));
-    const root = mkdtempSync(join(tmpdir(), "pivot-failed-resume-loopback-"));
-    const sourcePath = join(root, "source.jsonl");
-    writeFileSync(sourcePath, "{}\n");
-    const sourceStat = statSync(sourcePath, { bigint: true });
-    const profile = buildPivotRequestProfile(stub.baseURL, 600);
-    const descriptor = writeFrozenBundle(root, [{
-      session: {
-        key: "codex:failed-resume-session",
-        sessionId: "failed-resume-session",
-        rawHarness: "codex",
-        harness: "codex",
-        parserKind: "codex-rollout",
-        project: "test",
-        path: sourcePath,
-        date: "2026-08-03",
-        sizeBytes: Number(sourceStat.size),
-        mtimeNs: sourceStat.mtimeNs.toString(),
-        origin: "deja",
-        fingerprint: "placeholder",
-      } satisfies SessionMeta,
-      sample: buildStratifiedSample([
-        { role: "user", text: "请保留可以回查的出处" },
-        { role: "assistant", text: "已经记录出处" },
-      ], 600),
-    }], profile, pivotRequestProfileHash(profile));
-    const bundleDir = join(root, "input-bundle");
-    const entry = loadFrozenBundle(
-      bundleDir, descriptor.bundleHash, descriptor.requestProfileHash,
-    ).entries[0];
-    const configPath = join(root, "config.json");
-    writeFileSync(configPath, JSON.stringify({
-      llm: { apiKey: "loopback-test-key", model: "qwen-turbo", baseURL: stub.baseURL },
-    }));
-    const outputDir = join(root, "transport-output");
-    const args = [
-      "--mode", "transport",
-      "--input-bundle", bundleDir,
-      "--bundle-hash", descriptor.bundleHash,
-      "--request-profile-hash", descriptor.requestProfileHash,
-      "--session-key", entry.session.key,
-      "--output-dir", outputDir,
-      "--allow-external-llm",
-    ];
-    const previousConfig = process.env.LOCAL_MEMORY_CONFIG;
-    process.env.LOCAL_MEMORY_CONFIG = configPath;
-    try {
-      await expect(pivotMain(args)).rejects.toThrow("Stopped after 3 failed attempt(s)");
-      expect(stub.requests).toHaveLength(3);
-      const resultPath = join(outputDir, "results", `${entry.session.fingerprint}.json`);
-      const resultBeforeResume = readFileSync(resultPath, "utf8");
-      const result = JSON.parse(resultBeforeResume) as {
-        status: string;
-        attempts: number;
-        usage: { promptTokens: number; completionTokens: number; totalTokens: number };
-        attemptErrors: string[];
-      };
-      expect(result).toMatchObject({
-        status: "invalid",
-        attempts: 3,
-        usage: { promptTokens: 15, completionTokens: 6, totalTokens: 21 },
-      });
-      expect(result.attemptErrors).toHaveLength(3);
-      const invalid = JSON.parse(
-        readFileSync(join(outputDir, "invalid", `${entry.session.fingerprint}.json`), "utf8"),
-      ) as {
-        recovered: boolean;
-        attempts: Array<{
-          responseModel?: string;
-          finishReason?: string | null;
-          usage?: { promptTokens: number; completionTokens: number; totalTokens: number };
-        }>;
-      };
-      expect(invalid.recovered).toBeFalse();
-      expect(invalid.attempts).toHaveLength(3);
-      expect(invalid.attempts[0]).toMatchObject({
-        responseModel: PIVOT_MODEL,
-        finishReason: "stop",
-        usage: { promptTokens: 4, completionTokens: 1, totalTokens: 5 },
-      });
-
-      await expect(pivotMain(args)).rejects.toThrow("already records 3 attempt(s)");
-      expect(stub.requests).toHaveLength(3);
-      expect(readFileSync(resultPath, "utf8")).toBe(resultBeforeResume);
-    } finally {
-      if (previousConfig === undefined) delete process.env.LOCAL_MEMORY_CONFIG;
-      else process.env.LOCAL_MEMORY_CONFIG = previousConfig;
-      await stub.close();
-    }
-  }, 15_000);
-
-  it("refuses a crash-marked in-flight attempt without sending another request", async () => {
-    const stub = await startLoopbackStub(completionResponse({
-      content: JSON.stringify({ hasPivot: false, candidates: [] }),
-      finishReason: "stop",
-      model: PIVOT_MODEL,
-    }));
-    const root = mkdtempSync(join(tmpdir(), "pivot-in-flight-loopback-"));
-    const sourcePath = join(root, "source.jsonl");
-    writeFileSync(sourcePath, "{}\n");
-    const sourceStat = statSync(sourcePath, { bigint: true });
-    const profile = buildPivotRequestProfile(stub.baseURL, 600);
-    const descriptor = writeFrozenBundle(root, [{
-      session: {
-        key: "codex:in-flight-session",
-        sessionId: "in-flight-session",
-        rawHarness: "codex",
-        harness: "codex",
-        parserKind: "codex-rollout",
-        project: "test",
-        path: sourcePath,
-        date: "2026-08-03",
-        sizeBytes: Number(sourceStat.size),
-        mtimeNs: sourceStat.mtimeNs.toString(),
-        origin: "deja",
-        fingerprint: "placeholder",
-      } satisfies SessionMeta,
-      sample: buildStratifiedSample([
-        { role: "user", text: "崩溃后不要偷偷重发请求" },
-        { role: "assistant", text: "会先保留请求预算记录" },
-      ], 600),
-    }], profile, pivotRequestProfileHash(profile));
-    const bundleDir = join(root, "input-bundle");
-    const entry = loadFrozenBundle(
-      bundleDir, descriptor.bundleHash, descriptor.requestProfileHash,
-    ).entries[0];
-    const configPath = join(root, "config.json");
-    writeFileSync(configPath, JSON.stringify({
-      llm: { apiKey: "loopback-test-key", model: "qwen-turbo", baseURL: stub.baseURL },
-    }));
-    const outputDir = join(root, "transport-output");
-    const attemptsDir = join(outputDir, "attempts");
-    mkdirSync(attemptsDir, { recursive: true, mode: 0o700 });
-    const selectionHash = selectionIdentityHash("transport", [entry]);
-    writeFileSync(join(attemptsDir, `${entry.session.fingerprint}.json`), `${JSON.stringify({
-      schemaVersion: 1,
-      mode: "transport",
-      selectionHash,
-      outboundSampleSha256: entry.sampleSha256,
-      promptVersion: PROMPT_VERSION,
-      pipelineVersion: PIPELINE_VERSION,
-      model: PIVOT_MODEL,
-      requestProfileHash: descriptor.requestProfileHash,
-      bundleHash: descriptor.bundleHash,
-      session: entry.session,
-      maxSessionAttempts: profile.retryPolicy.maxSessionAttempts,
-      attempts: [{
-        attempt: 1,
-        state: "in-flight",
-        startedAt: "2026-08-03T00:00:00.000Z",
-      }],
-      updatedAt: "2026-08-03T00:00:00.000Z",
-    }, null, 2)}\n`, { mode: 0o600 });
-    const args = [
-      "--mode", "transport",
-      "--input-bundle", bundleDir,
-      "--bundle-hash", descriptor.bundleHash,
-      "--request-profile-hash", descriptor.requestProfileHash,
-      "--session-key", entry.session.key,
-      "--output-dir", outputDir,
-      "--allow-external-llm",
-    ];
-    const previousConfig = process.env.LOCAL_MEMORY_CONFIG;
-    process.env.LOCAL_MEMORY_CONFIG = configPath;
-    try {
-      await expect(pivotMain(args)).rejects.toThrow("incomplete attempt ledger");
-      expect(stub.requests).toHaveLength(0);
-      expect(JSON.parse(readFileSync(join(outputDir, "report-state.json"), "utf8")))
-        .toMatchObject({ status: "partial" });
-      expect(JSON.parse(readFileSync(join(outputDir, "summary.json"), "utf8")))
-        .toMatchObject({
-          reportStatus: "partial",
-          resultSessions: 0,
-          attemptAudit: {
-            validLedgers: 1,
-            invalidLedgers: 0,
-            startedAttempts: 1,
-            inFlightAttempts: 1,
-            recordedUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-          },
-        });
-    } finally {
-      if (previousConfig === undefined) delete process.env.LOCAL_MEMORY_CONFIG;
-      else process.env.LOCAL_MEMORY_CONFIG = previousConfig;
-      await stub.close();
-    }
-  }, 15_000);
-});