@lucern/sdk 0.2.0-alpha.6 → 0.2.0-alpha.8

package/dist/{lib/platform/sdk/beliefsClient.d.ts → beliefsClient.d.ts}

@@ -1,10 +1,13 @@
-import { type GatewayClientConfig, LucernApiError } from "./coreClient";
-import type { ForkBeliefResponse, JsonObject, ModulateConfidenceResponse } from "./types";
-export { LucernApiError };
-export type { PlatformGatewaySuccess } from "./coreClient";
-export type { CreateBeliefResponse, ForkBeliefResponse, ModulateConfidenceResponse, } from "./types";
+import { GatewayClientConfig, PlatformGatewaySuccess } from './coreClient.js';
+export { LucernApiError } from './coreClient.js';
+import { JsonObject, PlatformBeliefRecord, ModulateConfidenceResponse, ForkBeliefResponse } from './types.js';
+export { CreateBeliefResponse } from './types.js';
+import './contracts/workflow-runtime.contract.js';
+import './contracts/lens-workflow.contract.js';
+import './contracts/lens-filter.contract.js';
+
 /** Configuration for the beliefs client. Inherits gateway transport settings. */
-export type BeliefsClientConfig = GatewayClientConfig;
+type BeliefsClientConfig = GatewayClientConfig;
 /**
  * Input for creating a new belief within a topic scope.
  *
@@ -12,7 +15,7 @@ export type BeliefsClientConfig = GatewayClientConfig;
  * `canonicalText` remains available as a legacy alias for backwards compatibility.
  * Beliefs start as unscored drafts and can be scored via confidence modulation.
  */
-export type CreateBeliefInput = {
+type CreateBeliefInput = {
     topicId?: string;
     /** Preferred belief statement alias. */
     text?: string;
@@ -35,7 +38,7 @@ export type CreateBeliefInput = {
  * Input for recording a confidence change on a belief.
  * Confidence modulation is append-only — each call adds a new credence history entry.
  */
-export type ModulateConfidenceInput = {
+type ModulateConfidenceInput = {
     confidence: number;
     trigger?: "evidence_added" | "evidence_removed" | "contradiction_detected" | "contradiction_resolved" | "manual" | "decay" | "agent_assessment" | "merge_outcome" | "worktree_outcome" | "worktree_completed";
     rationale: string;
@@ -45,13 +48,13 @@ export type ModulateConfidenceInput = {
  * Input for forking a scored belief into a new formulation.
  * Scored beliefs are immutable — fork to evolve understanding.
  */
-export type ForkBeliefInput = {
+type ForkBeliefInput = {
     newFormulation: string;
     forkReason?: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse" | "manual";
     rationale?: string;
 };
 /** Input for changing a belief's lifecycle status. */
-export type UpdateBeliefStatusInput = {
+type UpdateBeliefStatusInput = {
     id?: string;
     nodeId?: string;
     beliefId?: string;
@@ -59,14 +62,14 @@ export type UpdateBeliefStatusInput = {
     reason?: string;
 };
 /** Input for updating a belief's rationale without refining its text. */
-export type UpdateBeliefRationaleInput = {
+type UpdateBeliefRationaleInput = {
     id?: string;
     nodeId?: string;
     beliefId?: string;
     rationale?: string;
 };
 /** Input for creating a belief-to-belief reasoning edge. */
-export type LinkBeliefsInput = {
+type LinkBeliefsInput = {
     fromNodeId: string;
     toNodeId: string;
     edgeType: string;
@@ -74,7 +77,7 @@ export type LinkBeliefsInput = {
     context?: string;
 };
 /** Input for unlinking a belief from an attached evidence item. */
-export type UnlinkBeliefEvidenceInput = {
+type UnlinkBeliefEvidenceInput = {
     beliefNodeId?: string;
     beliefId?: string;
     nodeId?: string;
@@ -82,14 +85,14 @@ export type UnlinkBeliefEvidenceInput = {
     evidenceId?: string;
 };
 /** Input for updating a belief's criticality classification. */
-export type UpdateBeliefCriticalityInput = {
+type UpdateBeliefCriticalityInput = {
     id?: string;
     nodeId?: string;
     beliefId?: string;
     criticality: "blocking" | "important" | "supporting" | "essential" | "nice_to_have";
 };
 /** Input for bulk-updating multiple beliefs' criticality. */
-export type BatchUpdateBeliefCriticalityInput = {
+type BatchUpdateBeliefCriticalityInput = {
     updates: Array<{
         beliefId: string;
         criticality: "blocking" | "important" | "supporting" | "essential" | "nice_to_have";
@@ -101,7 +104,7 @@ export type BatchUpdateBeliefCriticalityInput = {
     }>;
 };
 /** Input for moving beliefs into a different topic scope. */
-export type ReassignBeliefsTopicInput = {
+type ReassignBeliefsTopicInput = {
     beliefNodeIds?: string[];
     beliefIds?: string[];
     targetTopicId: string;
@@ -113,45 +116,47 @@ export type ReassignBeliefsTopicInput = {
  * @param config - Gateway transport configuration.
  * @returns An object with `createBelief`, `modulateConfidence`, and `forkBelief` methods.
  */
-export declare function createBeliefsClient(config?: BeliefsClientConfig): {
+declare function createBeliefsClient(config?: BeliefsClientConfig): {
     /**
      * Create a belief within a topic scope.
      */
-    createBelief(input: CreateBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
+    createBelief(input: CreateBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformBeliefRecord>>;
     /**
      * Record a confidence change for an existing belief.
      */
-    modulateConfidence(beliefId: string, input: ModulateConfidenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<ModulateConfidenceResponse>>;
+    modulateConfidence(beliefId: string, input: ModulateConfidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ModulateConfidenceResponse>>;
     /**
      * Fork a scored belief into a new formulation.
      */
-    forkBelief(beliefId: string, input: ForkBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<ForkBeliefResponse>>;
+    forkBelief(beliefId: string, input: ForkBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ForkBeliefResponse>>;
     /**
      * Update a belief's lifecycle status.
      */
-    updateBeliefStatus(input: UpdateBeliefStatusInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    updateBeliefStatus(input: UpdateBeliefStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Update a belief's rationale without changing its text.
      */
-    updateBeliefRationale(input: UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    updateBeliefRationale(input: UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Create a typed relationship between two beliefs.
      */
-    linkBeliefs(input: LinkBeliefsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    linkBeliefs(input: LinkBeliefsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Remove an evidence attachment from a belief.
      */
-    unlinkBeliefEvidence(input: UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    unlinkBeliefEvidence(input: UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Update a belief's criticality metadata.
      */
-    updateBeliefCriticality(input: UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    updateBeliefCriticality(input: UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Update multiple beliefs' criticality in one mutation.
      */
-    batchUpdateBeliefCriticality(input: BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    batchUpdateBeliefCriticality(input: BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Reassign beliefs to a different topic scope.
      */
-    reassignBeliefsTopic(input: ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    reassignBeliefsTopic(input: ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
 };
+
+export { type BatchUpdateBeliefCriticalityInput, type BeliefsClientConfig, type CreateBeliefInput, type ForkBeliefInput, ForkBeliefResponse, type LinkBeliefsInput, type ModulateConfidenceInput, ModulateConfidenceResponse, PlatformGatewaySuccess, type ReassignBeliefsTopicInput, type UnlinkBeliefEvidenceInput, type UpdateBeliefCriticalityInput, type UpdateBeliefRationaleInput, type UpdateBeliefStatusInput, createBeliefsClient };

package/dist/beliefsClient.js

@@ -0,0 +1,477 @@
+// src/coreClient.ts
+var LucernApiError = class extends Error {
+  code;
+  status;
+  invariant;
+  suggestion;
+  details;
+  requestId;
+  correlationId;
+  policyTraceId;
+  constructor(args) {
+    super(args.message);
+    this.name = "LucernApiError";
+    this.code = args.code;
+    this.status = args.status;
+    this.invariant = args.invariant;
+    this.suggestion = args.suggestion;
+    this.details = args.details;
+    this.requestId = args.requestId;
+    this.correlationId = args.correlationId;
+    this.policyTraceId = args.policyTraceId;
+  }
+};
+function fillRandomBytes(length) {
+  const bytes = new Uint8Array(length);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+    return bytes;
+  }
+  for (let index = 0; index < length; index += 1) {
+    bytes[index] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
+function generatePortableRequestId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = fillRandomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (value) => value.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(
+    6,
+    8
+  ).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+}
+function randomIdempotencyKey() {
+  return generatePortableRequestId();
+}
+function isRetryableStatus(status) {
+  return status >= 500 || status === 408 || status === 429;
+}
+function fallbackErrorCode(status) {
+  if (status === 401) {
+    return "AUTHENTICATION_REQUIRED";
+  }
+  if (status === 403) {
+    return "FORBIDDEN";
+  }
+  if (status === 404) {
+    return "NOT_FOUND";
+  }
+  if (status === 408) {
+    return "UPSTREAM_ERROR";
+  }
+  if (status === 409) {
+    return "CONFLICT";
+  }
+  if (status === 429) {
+    return "RATE_LIMIT_EXCEEDED";
+  }
+  if (status >= 500) {
+    return "UPSTREAM_ERROR";
+  }
+  return "INTERNAL_ERROR";
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseRetryAfterMs(value) {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const numeric = Number(trimmed);
+  if (Number.isFinite(numeric)) {
+    return Math.max(0, Math.round(numeric * 1e3));
+  }
+  const parsedDate = Date.parse(trimmed);
+  if (Number.isFinite(parsedDate)) {
+    return Math.max(0, parsedDate - Date.now());
+  }
+  return null;
+}
+function computeRetryDelayMs(args) {
+  const baseDelay = args.status === 429 ? Math.max(
+    args.retryAfterMs ?? 0,
+    Math.min(1e3 * 2 ** args.attempt, 1e4)
+  ) : Math.min(1e3 * 2 ** args.attempt, 4e3);
+  if (args.status !== 429) {
+    return baseDelay;
+  }
+  const jitterWindow = Math.max(250, Math.round(baseDelay * 0.25));
+  return baseDelay + Math.round(Math.random() * jitterWindow);
+}
+function timeoutError(timeoutMs) {
+  const error = new Error(`Request timed out after ${timeoutMs}ms`);
+  error.name = "AbortError";
+  return error;
+}
+function readPolicySummaryFromDetails(details) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) {
+    return null;
+  }
+  const directSummary = details.summary;
+  if (typeof directSummary === "string" && directSummary.trim().length > 0) {
+    return directSummary.trim();
+  }
+  const policy = details.policy;
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) {
+    return null;
+  }
+  const explanation = policy.explanation;
+  if (!explanation || typeof explanation !== "object" || Array.isArray(explanation)) {
+    return null;
+  }
+  const nestedSummary = explanation.summary;
+  if (typeof nestedSummary === "string" && nestedSummary.trim().length > 0) {
+    return nestedSummary.trim();
+  }
+  return null;
+}
+function createGatewayRequestClient(config = {}) {
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "";
+  const maxRetries = config.maxRetries ?? 2;
+  const requestIdFactory = config.requestIdFactory ?? (() => generatePortableRequestId());
+  async function resolveAuthHeaders() {
+    if (!config.getAuthHeaders) {
+      return {};
+    }
+    return await config.getAuthHeaders();
+  }
+  async function fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      return await fetchImpl(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw timeoutError(timeoutMs);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async function parsePayload(response) {
+    const text = await response.text();
+    if (!text) {
+      return null;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+  function resolveTimeoutMs(method, requestTimeoutMs) {
+    if (typeof requestTimeoutMs === "number") {
+      return requestTimeoutMs;
+    }
+    const methodTimeoutMs = config.timeoutMsByMethod?.[method];
+    if (typeof methodTimeoutMs === "number") {
+      return methodTimeoutMs;
+    }
+    return config.timeoutMs ?? 15e3;
+  }
+  function buildApiError(args) {
+    const failure = args.failure;
+    const legacyError = failure && typeof failure.error === "object" && failure.error !== null ? failure.error : failure?.legacyError;
+    const correlationId = failure?.correlationId ?? args.response.headers.get("x-lucern-correlation-id")?.trim() ?? args.requestId;
+    const policyTraceId = failure?.policyTraceId ?? args.response.headers.get("x-lucern-policy-trace-id")?.trim() ?? null;
+    const details = failure?.details ?? legacyError?.details;
+    const policySummary = readPolicySummaryFromDetails(details);
+    return new LucernApiError({
+      code: failure?.code ?? legacyError?.code ?? fallbackErrorCode(args.response.status),
+      message: policySummary ?? (typeof failure?.error === "string" ? failure.error : legacyError?.message ?? (args.response.ok ? "Platform API returned an invalid success payload." : "Platform API request failed.")),
+      status: args.response.status,
+      invariant: failure?.invariant,
+      suggestion: failure?.suggestion,
+      details,
+      requestId: args.requestId,
+      correlationId,
+      policyTraceId
+    });
+  }
+  async function request(args) {
+    const authHeaders = await resolveAuthHeaders();
+    const method = args.method ?? "GET";
+    const timeoutMs = resolveTimeoutMs(method, args.timeoutMs);
+    const headers = new Headers({
+      "content-type": "application/json",
+      ...authHeaders
+    });
+    if (args.idempotencyKey) {
+      headers.set("idempotency-key", args.idempotencyKey);
+    }
+    const requestId = headers.get("x-correlation-id")?.trim() || headers.get("x-request-id")?.trim() || args.requestId || requestIdFactory();
+    if (!headers.has("x-correlation-id") && !headers.has("x-request-id")) {
+      headers.set("x-correlation-id", requestId);
+    }
+    const url = `${baseUrl}${args.path}`;
+    const serializedBody = args.body ? JSON.stringify(args.body) : void 0;
+    const init = {
+      method,
+      headers,
+      body: serializedBody
+    };
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const hookRequestContext = {
+        requestId,
+        attempt,
+        maxRetries,
+        method,
+        path: args.path,
+        url,
+        headers: new Headers(headers),
+        body: serializedBody,
+        timeoutMs
+      };
+      await config.onRequest?.(hookRequestContext);
+      const startedAt = Date.now();
+      try {
+        const response = await fetchWithTimeout(url, init, timeoutMs);
+        const responseClone = response.clone();
+        const payload = await parsePayload(response);
+        const retryAfterMs = parseRetryAfterMs(
+          response.headers.get("Retry-After")
+        );
+        if (!response.ok || !payload?.success) {
+          const failure = payload && !payload.success ? payload : null;
+          const apiError = buildApiError({
+            requestId,
+            response,
+            failure
+          });
+          const willRetry = attempt < maxRetries && isRetryableStatus(response.status);
+          await config.onResponse?.({
+            ...hookRequestContext,
+            durationMs: Date.now() - startedAt,
+            status: response.status,
+            response: responseClone,
+            error: apiError,
+            correlationId: apiError.correlationId ?? requestId,
+            policyTraceId: apiError.policyTraceId ?? null,
+            retryAfterMs,
+            willRetry
+          });
+          if (willRetry) {
+            lastError = apiError;
+            await delay(
+              computeRetryDelayMs({
+                attempt,
+                status: response.status,
+                retryAfterMs
+              })
+            );
+            continue;
+          }
+          throw apiError;
+        }
+        const successPayload = payload;
+        await config.onResponse?.({
+          ...hookRequestContext,
+          durationMs: Date.now() - startedAt,
+          status: response.status,
+          response: responseClone,
+          correlationId: successPayload.correlationId ?? response.headers.get("x-lucern-correlation-id")?.trim() ?? requestId,
+          policyTraceId: successPayload.policyTraceId ?? response.headers.get("x-lucern-policy-trace-id")?.trim() ?? null,
+          idempotentReplay: successPayload.idempotentReplay,
+          retryAfterMs,
+          willRetry: false
+        });
+        return successPayload;
+      } catch (fetchError) {
+        if (fetchError instanceof LucernApiError) {
+          throw fetchError;
+        }
+        const willRetry = attempt < maxRetries;
+        await config.onResponse?.({
+          ...hookRequestContext,
+          durationMs: Date.now() - startedAt,
+          error: fetchError,
+          correlationId: requestId,
+          policyTraceId: null,
+          willRetry
+        });
+        lastError = fetchError;
+        if (willRetry) {
+          await delay(computeRetryDelayMs({ attempt }));
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Platform API request failed after retries.");
+  }
+  return {
+    request
+  };
+}
+
+// src/sdkSurface.ts
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function normalizeVerificationStatus(value) {
+  const status = cleanString(value);
+  if (!status) {
+    return void 0;
+  }
+  if (status === "verified") {
+    return "human_verified";
+  }
+  if (status === "rejected") {
+    return "contradicted";
+  }
+  return status;
+}
+function resolveTopicId(value) {
+  return cleanString(value.topicId);
+}
+function resolveText(value) {
+  return cleanString(value.text) ?? cleanString(value.canonicalText);
+}
+function normalizeNodeWriteInput(value) {
+  const topicId = resolveTopicId(value);
+  const text = resolveText(value);
+  const verificationStatus = normalizeVerificationStatus(value.verificationStatus);
+  const next = { ...value };
+  if (topicId) {
+    next.topicId = topicId;
+  }
+  if (text) {
+    next.text = text;
+    next.canonicalText = text;
+  }
+  if (verificationStatus) {
+    next.verificationStatus = verificationStatus;
+  }
+  return next;
+}
+
+// src/beliefsClient.ts
+function createBeliefsClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    /**
+     * Create a belief within a topic scope.
+     */
+    async createBelief(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs",
+        method: "POST",
+        body: normalizeNodeWriteInput(input),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Record a confidence change for an existing belief.
+     */
+    async modulateConfidence(beliefId, input, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}/confidence`,
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Fork a scored belief into a new formulation.
+     */
+    async forkBelief(beliefId, input, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}/fork`,
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Update a belief's lifecycle status.
+     */
+    async updateBeliefStatus(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/update-status",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Update a belief's rationale without changing its text.
+     */
+    async updateBeliefRationale(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/update-rationale",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Create a typed relationship between two beliefs.
+     */
+    async linkBeliefs(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/link",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Remove an evidence attachment from a belief.
+     */
+    async unlinkBeliefEvidence(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/unlink-evidence",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Update a belief's criticality metadata.
+     */
+    async updateBeliefCriticality(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/update-criticality",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Update multiple beliefs' criticality in one mutation.
+     */
+    async batchUpdateBeliefCriticality(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/batch-update-criticality",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    /**
+     * Reassign beliefs to a different topic scope.
+     */
+    async reassignBeliefsTopic(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/beliefs/reassign-topic",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
+export { LucernApiError, createBeliefsClient };
+//# sourceMappingURL=beliefsClient.js.map
+//# sourceMappingURL=beliefsClient.js.map