@remnic/core 9.3.651 → 9.3.652

package/src/access-service-health.test.ts

@@ -0,0 +1,402 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { EngramAccessService } from "./access-service.js";
+import { parseConfig } from "./config.js";
+import { namespaceCollectionName } from "./namespaces/search.js";
+import type { Orchestrator } from "./orchestrator.js";
+import type { SearchBackend } from "./search/port.js";
+
+function makeQmd(overrides: Partial<SearchBackend> & Record<string, unknown>): SearchBackend {
+  return {
+    async probe() {
+      return false;
+    },
+    isAvailable() {
+      return false;
+    },
+    debugStatus() {
+      return "backend=noop";
+    },
+    async search() {
+      return [];
+    },
+    async searchGlobal() {
+      return [];
+    },
+    async bm25Search() {
+      return [];
+    },
+    async vectorSearch() {
+      return [];
+    },
+    async hybridSearch() {
+      return [];
+    },
+    async update() {},
+    async updateCollection() {},
+    async embed() {},
+    async embedCollection() {},
+    async ensureCollection() {
+      return "skipped";
+    },
+    ...overrides,
+  } as SearchBackend;
+}
+
+test("health reports active QMD version and collection state", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const qmd = makeQmd({
+      probe: async () => true,
+      isAvailable: () => true,
+      debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+      checkCollection: async (collection, execution) => {
+        assert.equal(collection, "remnic-memory");
+        assert.ok(execution?.signal instanceof AbortSignal);
+        return "present";
+      },
+      getVersionStatus: () => ({
+        installedVersion: "qmd 2.5.3",
+        supportedVersion: "2.5.3",
+        supported: true,
+        newerThanSupported: false,
+        upgradeAvailable: false,
+        capabilities: { doctor: true },
+      }),
+      isDaemonMode: () => false,
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd,
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmdEnabled, true);
+    assert.deepEqual(health.qmd, {
+      enabled: true,
+      active: true,
+      degraded: false,
+      mode: "cli",
+      collection: "remnic-memory",
+      collectionState: "present",
+      installedVersion: "qmd 2.5.3",
+      supportedVersion: "2.5.3",
+      supported: true,
+      upgradeAvailable: false,
+      doctorAvailable: true,
+      debugStatus: "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+    });
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health marks QMD as degraded when configured search falls back to noop", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-degraded-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({}),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmd.active, false);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.mode, "fallback");
+    assert.equal(health.qmd.collectionState, "unknown");
+    assert.equal(health.qmd.debugStatus, "backend=noop");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health marks QMD as degraded when the checked collection is missing", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-missing-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => true,
+        isAvailable: () => true,
+        debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+        checkCollection: async () => "missing",
+        isDaemonMode: () => false,
+      }),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmd.collectionState, "missing");
+    assert.equal(health.qmd.active, false);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.mode, "fallback");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health reports degraded diagnostics when read-only root QMD probe fails", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-stale-probe-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => false,
+        isAvailable: () => true,
+        debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+        checkCollection: async () => "present",
+        isDaemonMode: () => false,
+      }),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.mode, "cli");
+    assert.equal(health.qmd.collectionState, "unknown");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health uses read-only root QMD availability checks", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-readonly-"));
+  try {
+    const config = parseConfig({
+      memoryDir,
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+    });
+    let checkAvailabilityCalled = false;
+    let probeCalled = false;
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => {
+          probeCalled = true;
+          return true;
+        },
+        checkAvailability: async (execution) => {
+          checkAvailabilityCalled = true;
+          assert.ok(execution?.signal instanceof AbortSignal);
+          return true;
+        },
+        isAvailable: () => true,
+        debugStatus: () => "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+        checkCollection: async () => "present",
+        isDaemonMode: () => false,
+      }),
+      async getStorage() {
+        return { dir: memoryDir };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health();
+
+    assert.equal(checkAvailabilityCalled, true);
+    assert.equal(probeCalled, false);
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, false);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("health reports namespace-scoped QMD backend state", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-ns-"));
+  try {
+    const teamDir = path.join(rootDir, "namespaces", "team");
+    const config = parseConfig({
+      memoryDir: rootDir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+      namespacePolicies: [{ name: "team", readPrincipals: [], writePrincipals: [] }],
+    });
+    const expectedCollection = namespaceCollectionName("remnic-memory", "team", {
+      defaultNamespace: "default",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({}),
+      async getStorage(namespace: string) {
+        return { dir: namespace === "team" ? teamDir : rootDir };
+      },
+      async searchHealthForNamespace(namespace: string, execution?: { signal?: AbortSignal }) {
+        assert.equal(namespace, "team");
+        assert.ok(execution?.signal instanceof AbortSignal);
+        return {
+          collection: expectedCollection,
+          available: true,
+          collectionState: "present",
+          debugStatus: "cli=true daemon=false cliPath=qmd cliVersion=qmd 2.5.3",
+          installedVersion: "qmd 2.5.3",
+          supportedVersion: "2.5.3",
+          supported: true,
+          upgradeAvailable: false,
+          doctorAvailable: true,
+          daemonMode: false,
+        };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health("team");
+
+    assert.equal(health.memoryDir, teamDir);
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, false);
+    assert.equal(health.qmd.collection, expectedCollection);
+    assert.equal(health.qmd.collectionState, "present");
+    assert.equal(health.qmd.installedVersion, "qmd 2.5.3");
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});
+
+test("health marks namespace QMD unknown collection state degraded", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-ns-unknown-"));
+  try {
+    const teamDir = path.join(rootDir, "namespaces", "team");
+    const config = parseConfig({
+      memoryDir: rootDir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+      namespacePolicies: [{ name: "team", readPrincipals: [], writePrincipals: [] }],
+    });
+    const expectedCollection = namespaceCollectionName("remnic-memory", "team", {
+      defaultNamespace: "default",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({}),
+      async getStorage(namespace: string) {
+        return { dir: namespace === "team" ? teamDir : rootDir };
+      },
+      async searchHealthForNamespace(namespace: string, execution?: { signal?: AbortSignal }) {
+        assert.equal(namespace, "team");
+        assert.ok(execution?.signal instanceof AbortSignal);
+        return {
+          collection: expectedCollection,
+          available: true,
+          collectionState: "unknown",
+          debugStatus: "cli=true collection=unknown",
+          installedVersion: "qmd 2.5.3",
+          supportedVersion: "2.5.3",
+          supported: true,
+          upgradeAvailable: false,
+          doctorAvailable: true,
+          daemonMode: false,
+        };
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health("team");
+
+    assert.equal(health.memoryDir, teamDir);
+    assert.equal(health.qmd.active, true);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.collection, expectedCollection);
+    assert.equal(health.qmd.collectionState, "unknown");
+    assert.equal(health.qmd.mode, "cli");
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});
+
+test("health keeps namespace QMD failures scoped to the namespace", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-qmd-ns-fail-"));
+  try {
+    const teamDir = path.join(rootDir, "namespaces", "team");
+    const config = parseConfig({
+      memoryDir: rootDir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      searchBackend: "qmd",
+      qmdEnabled: true,
+      qmdCollection: "remnic-memory",
+      namespacePolicies: [{ name: "team", readPrincipals: [], writePrincipals: [] }],
+    });
+    const expectedCollection = namespaceCollectionName("remnic-memory", "team", {
+      defaultNamespace: "default",
+    });
+    const service = new EngramAccessService({
+      config,
+      qmd: makeQmd({
+        probe: async () => true,
+        isAvailable: () => true,
+        debugStatus: () => "root-qmd-should-not-leak",
+        checkCollection: async () => "present",
+      }),
+      async getStorage(namespace: string) {
+        return { dir: namespace === "team" ? teamDir : rootDir };
+      },
+      async searchHealthForNamespace() {
+        throw new Error(`namespace probe timed out at ${teamDir}/qmd/index.sqlite`);
+      },
+    } as unknown as Orchestrator);
+
+    const health = await service.health("team");
+
+    assert.equal(health.memoryDir, teamDir);
+    assert.equal(health.qmd.collection, expectedCollection);
+    assert.equal(health.qmd.active, false);
+    assert.equal(health.qmd.degraded, true);
+    assert.equal(health.qmd.collectionState, "unknown");
+    assert.equal(health.qmd.mode, "fallback");
+    assert.equal(health.qmd.debugStatus, "backend=namespace-unavailable error=Error");
+    assert.doesNotMatch(health.qmd.debugStatus, /root-qmd-should-not-leak/);
+    assert.doesNotMatch(health.qmd.debugStatus, /index\.sqlite/);
+    assert.doesNotMatch(health.qmd.debugStatus, /remnic-health-qmd-ns-fail/);
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});

package/src/access-service.ts

@@ -38,6 +38,7 @@ import {
   runMemoryGovernance,
 } from "./maintenance/memory-governance.js";
 import { runProcedureMining } from "./procedural/procedure-miner.js";
+import { displayErrorDetail } from "./runtime/better-sqlite.js";
 import type { PatternReinforcementResult } from "./maintenance/pattern-reinforcement.js";
 import type { LiveConnectorsRunSummary } from "./live-connectors-runner.js";
 import type { WearablesService } from "./wearables/service.js";
@@ -279,10 +280,32 @@ export interface EngramAccessHealthResponse {
   defaultNamespace: string;
   searchBackend: string;
   qmdEnabled: boolean;
+  qmd: EngramAccessQmdHealthResponse;
   nativeKnowledgeEnabled: boolean;
   projectionAvailable: boolean;
 }
 
+export type EngramAccessQmdCollectionState =
+  | "present"
+  | "missing"
+  | "unknown"
+  | "skipped";
+
+export interface EngramAccessQmdHealthResponse {
+  enabled: boolean;
+  active: boolean;
+  degraded: boolean;
+  mode: "cli" | "daemon" | "fallback" | "disabled" | "not-selected";
+  collection: string;
+  collectionState: EngramAccessQmdCollectionState;
+  installedVersion: string | null;
+  supportedVersion: string | null;
+  supported: boolean | null;
+  upgradeAvailable: boolean | null;
+  doctorAvailable: boolean | null;
+  debugStatus: string;
+}
+
 export interface EngramAccessRecallRequest {
   query: string;
   sessionKey?: string;
@@ -2412,6 +2435,8 @@ export class EngramAccessService {
   async health(namespace?: string): Promise<EngramAccessHealthResponse> {
     const resolvedNamespace = this.resolveNamespace(namespace);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const searchBackend = this.orchestrator.config.searchBackend ?? "qmd";
+    const qmdEnabled = this.orchestrator.config.qmdEnabled === true;
     let projectionAvailable = false;
     try {
       await stat(getMemoryProjectionPath(storage.dir));
@@ -2425,13 +2450,260 @@ export class EngramAccessService {
       memoryDir: storage.dir,
       namespacesEnabled: this.orchestrator.config.namespacesEnabled === true,
       defaultNamespace: this.orchestrator.config.defaultNamespace,
-      searchBackend: this.orchestrator.config.searchBackend ?? "qmd",
-      qmdEnabled: this.orchestrator.config.qmdEnabled === true,
+      searchBackend,
+      qmdEnabled,
+      qmd: await this.qmdHealth(
+        searchBackend,
+        qmdEnabled,
+        resolvedNamespace,
+        this.qmdCollectionForHealth(resolvedNamespace, storage.dir),
+      ),
       nativeKnowledgeEnabled: this.orchestrator.config.nativeKnowledge?.enabled === true,
       projectionAvailable,
     };
   }
 
+  private qmdCollectionForHealth(namespace: string, storageDir: string): string {
+    if (this.orchestrator.config.namespacesEnabled !== true) {
+      return this.orchestrator.config.qmdCollection;
+    }
+
+    const useLegacyDefaultCollection =
+      namespace === this.orchestrator.config.defaultNamespace &&
+      storageDir === this.orchestrator.config.memoryDir;
+    return namespaceCollectionName(this.orchestrator.config.qmdCollection, namespace, {
+      defaultNamespace: this.orchestrator.config.defaultNamespace,
+      useLegacyDefaultCollection,
+    });
+  }
+
+  private async qmdHealth(
+    searchBackend: string,
+    qmdEnabled: boolean,
+    namespace: string,
+    collection: string,
+  ): Promise<EngramAccessQmdHealthResponse> {
+    if (searchBackend !== "qmd" || !qmdEnabled) {
+      return {
+        enabled: qmdEnabled,
+        active: false,
+        degraded: false,
+        mode: searchBackend !== "qmd" ? "not-selected" : "disabled",
+        collection,
+        collectionState: "skipped",
+        installedVersion: null,
+        supportedVersion: null,
+        supported: null,
+        upgradeAvailable: null,
+        doctorAvailable: null,
+        debugStatus: searchBackend !== "qmd" ? `backend=${searchBackend}` : "backend=disabled",
+      };
+    }
+
+    if (this.orchestrator.config.namespacesEnabled === true) {
+      const namespaceHealth = await this.namespaceQmdHealth(searchBackend, qmdEnabled, namespace, collection);
+      if (namespaceHealth) return namespaceHealth;
+    }
+
+    const qmd = this.orchestrator.qmd;
+    if (!qmd) {
+      return {
+        enabled: true,
+        active: false,
+        degraded: true,
+        mode: "fallback",
+        collection,
+        collectionState: "unknown",
+        installedVersion: null,
+        supportedVersion: null,
+        supported: null,
+        upgradeAvailable: null,
+        doctorAvailable: null,
+        debugStatus: "backend=unavailable",
+      };
+    }
+    const diagnosticAvailable = await this.qmdProbeAvailable(searchBackend, qmdEnabled);
+    const operationalAvailable = diagnosticAvailable || qmd.isAvailable();
+    const collectionState = diagnosticAvailable
+      ? await this.qmdCollectionState(searchBackend, qmdEnabled, collection)
+      : "unknown";
+    const active = operationalAvailable && collectionState !== "missing";
+    const degraded =
+      searchBackend === "qmd" &&
+      qmdEnabled &&
+      (!active || !diagnosticAvailable || collectionState === "unknown");
+    const debugStatus = qmd.debugStatus();
+    const versionStatus =
+      "getVersionStatus" in qmd && typeof qmd.getVersionStatus === "function"
+        ? qmd.getVersionStatus()
+        : null;
+    const daemonMode =
+      "isDaemonMode" in qmd && typeof qmd.isDaemonMode === "function"
+        ? qmd.isDaemonMode() === true
+        : false;
+    const mode =
+      searchBackend !== "qmd"
+        ? "not-selected"
+        : !qmdEnabled
+        ? "disabled"
+        : !active
+        ? "fallback"
+        : daemonMode
+        ? "daemon"
+        : "cli";
+
+    return {
+      enabled: qmdEnabled,
+      active,
+      degraded,
+      mode,
+      collection,
+      collectionState,
+      installedVersion: versionStatus?.installedVersion ?? null,
+      supportedVersion: versionStatus?.supportedVersion ?? null,
+      supported: versionStatus?.supported ?? null,
+      upgradeAvailable: versionStatus?.upgradeAvailable ?? null,
+      doctorAvailable: versionStatus?.capabilities?.doctor ?? null,
+      debugStatus,
+    };
+  }
+
+  private async namespaceQmdHealth(
+    searchBackend: string,
+    qmdEnabled: boolean,
+    namespace: string,
+    fallbackCollection: string,
+  ): Promise<EngramAccessQmdHealthResponse | null> {
+    if (searchBackend !== "qmd" || !qmdEnabled) return null;
+    const searchHealthForNamespace = (
+      this.orchestrator as Orchestrator & {
+        searchHealthForNamespace?: (
+          namespace: string,
+          execution?: { signal?: AbortSignal },
+        ) => Promise<{
+          collection: string;
+          available: boolean;
+          collectionState: EngramAccessQmdCollectionState;
+          debugStatus: string;
+          installedVersion: string | null;
+          supportedVersion: string | null;
+          supported: boolean | null;
+          upgradeAvailable: boolean | null;
+          doctorAvailable: boolean | null;
+          daemonMode: boolean | null;
+        }>;
+      }
+    ).searchHealthForNamespace;
+    if (typeof searchHealthForNamespace !== "function") return null;
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2_000);
+    timer.unref?.();
+    try {
+      const health = await searchHealthForNamespace.call(this.orchestrator, namespace, {
+        signal: controller.signal,
+      });
+      const active = health.available && health.collectionState !== "missing";
+      const degraded = !active || health.collectionState === "unknown";
+      const mode =
+        !active
+          ? "fallback"
+          : health.daemonMode === true
+          ? "daemon"
+          : "cli";
+
+      return {
+        enabled: true,
+        active,
+        degraded,
+        mode,
+        collection: health.collection || fallbackCollection,
+        collectionState: health.collectionState,
+        installedVersion: health.installedVersion,
+        supportedVersion: health.supportedVersion,
+        supported: health.supported,
+        upgradeAvailable: health.upgradeAvailable,
+        doctorAvailable: health.doctorAvailable,
+        debugStatus: health.debugStatus,
+      };
+    } catch (error) {
+      const detail = displayErrorDetail(error) || "unknown";
+      return {
+        enabled: true,
+        active: false,
+        degraded: true,
+        mode: "fallback",
+        collection: fallbackCollection,
+        collectionState: "unknown",
+        installedVersion: null,
+        supportedVersion: null,
+        supported: null,
+        upgradeAvailable: null,
+        doctorAvailable: null,
+        debugStatus: `backend=namespace-unavailable error=${detail}`,
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  private async qmdCollectionState(
+    searchBackend: string,
+    qmdEnabled: boolean,
+    collection: string,
+  ): Promise<EngramAccessQmdCollectionState> {
+    if (searchBackend !== "qmd" || !qmdEnabled) return "skipped";
+    const qmd = this.orchestrator.qmd;
+    if (!qmd.isAvailable()) return "unknown";
+    if (!qmd.checkCollection) return "skipped";
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2_000);
+    timer.unref?.();
+    try {
+      return await qmd.checkCollection(collection, {
+        signal: controller.signal,
+      });
+    } catch {
+      return "unknown";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  private async qmdProbeAvailable(
+    searchBackend: string,
+    qmdEnabled: boolean,
+  ): Promise<boolean> {
+    if (searchBackend !== "qmd" || !qmdEnabled) return false;
+    const qmd = this.orchestrator.qmd;
+    if (!qmd) return false;
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2_000);
+    timer.unref?.();
+    try {
+      return await new Promise<boolean>((resolve) => {
+        const onAbort = () => {
+          controller.signal.removeEventListener("abort", onAbort);
+          resolve(false);
+        };
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+        const probe =
+          typeof qmd.checkAvailability === "function"
+            ? qmd.checkAvailability({ signal: controller.signal })
+            : qmd.probe();
+        probe
+          .then(resolve, () => resolve(false))
+          .finally(() => {
+            controller.signal.removeEventListener("abort", onAbort);
+          });
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
   async actionConfidence(
     request: EngramAccessActionConfidenceRequest = {},
   ): Promise<EngramAccessActionConfidenceResponse> {