@lucern/sdk 1.0.29 → 1.0.30

package/dist/decisions/index.js

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/performance/noBarrelFile: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the facade/barrel export is intentional.
 import { createLucernClient } from "../client.js";
 export * as methodSchemas from "@lucern/contracts/sdk-methods.contract";
 export * as toolSchemas from "@lucern/contracts/tool-contracts";

package/dist/decisionsClient.d.ts

@@ -1,8 +1,8 @@
 import { type GatewayClientConfig, LucernApiError } from "./coreClient";
 import type { GetJudgmentResponse, JudgmentCalibrationResponse, JudgmentReadinessResponse, JudgmentTransitionAuditIntegrityResponse, ListJudgmentsResponse, PendingJudgmentOutcomeRecord, RecordJudgmentOutcomeResponse, RecordJudgmentResponse, TopicIdentifierInput } from "./types";
-export { LucernApiError };
 export type { PlatformGatewaySuccess } from "./coreClient";
 export type { GetJudgmentResponse, JudgmentCalibrationResponse, JudgmentReadinessResponse, JudgmentTransitionAuditIntegrityResponse, ListJudgmentsResponse, PendingJudgmentOutcomeReviewResponse, RecordJudgmentOutcomeResponse, RecordJudgmentResponse, } from "./types";
+export { LucernApiError };
 /** Configuration for the decisions client. */
 export type DecisionsClientConfig = GatewayClientConfig;
 /** Input for recording a new judgment (irreversible decision commitment). */
@@ -32,11 +32,11 @@ export type ListJudgmentsInput = {
     limit?: number;
 } & TopicIdentifierInput;
 /** Input for recording the real-world outcome of a judgment. */
-export type RecordJudgmentOutcomeInput = {
+export interface RecordJudgmentOutcomeInput {
+    notes?: string;
     outcome: "pending" | "successful" | "unsuccessful" | "mixed" | "unknown" | "too_early";
     outcomeNotes?: string;
-    notes?: string;
-};
+}
 /** Input for retrieving judgment calibration analytics. */
 export type GetJudgmentCalibrationInput = {
     topicId?: string;

package/dist/decisionsClient.js

@@ -1,6 +1,15 @@
-import { createGatewayRequestClient, LucernApiError, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
+import { createGatewayRequestClient, 
+// biome-ignore lint/style/noExportedImports: decisionsClient preserves this legacy compatibility re-export while package root also exports coreClient.
+LucernApiError, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
 import { createListResult, mapGatewayData, normalizeTopicQuery, withTopicAlias, } from "./sdkSurface.js";
 export { LucernApiError };
+function booleanQueryParam(value) {
+    if (typeof value !== "boolean") {
+        return;
+    }
+    return value ? "true" : "false";
+}
 /**
  * Create the judgments client for decision lifecycle operations.
  * @param config - Gateway transport configuration.
@@ -12,18 +21,16 @@ export function createDecisionsClient(config = {}) {
         /**
          * List judgments for a topic scope.
          */
-        async listJudgments(query) {
-            return gateway.request({
+        listJudgments(query) {
+            return gateway
+                .request({
                 path: `/api/platform/v1/graph/judgments${toQueryString({
                     ...normalizeTopicQuery(query),
-                    includeArchived: typeof query.includeArchived === "boolean"
-                        ? query.includeArchived
-                            ? "true"
-                            : "false"
-                        : undefined,
+                    includeArchived: booleanQueryParam(query.includeArchived),
                     limit: query.limit,
                 })}`,
-            }).then((response) => mapGatewayData(response, (data) => {
+            })
+                .then((response) => mapGatewayData(response, (data) => {
                 const rows = Array.isArray(data) ? data : [];
                 const judgments = rows.map((row) => withTopicAlias(row));
                 return {
@@ -34,17 +41,19 @@ export function createDecisionsClient(config = {}) {
         /**
          * Get a single judgment by identifier.
          */
-        async getJudgment(judgmentId) {
-            return gateway.request({
+        getJudgment(judgmentId) {
+            return gateway
+                .request({
                 path: `/api/platform/v1/graph/judgments/${encodeURIComponent(judgmentId)}`,
-            }).then((response) => mapGatewayData(response, (data) => data && typeof data === "object"
+            })
+                .then((response) => mapGatewayData(response, (data) => data && typeof data === "object"
                 ? withTopicAlias(data)
                 : data));
         },
         /**
          * Get readiness signals for creating a judgment.
          */
-        async getJudgmentReadiness(query) {
+        getJudgmentReadiness(query) {
             return gateway.request({
                 path: `/api/platform/v1/graph/judgments/readiness${toQueryString(normalizeTopicQuery(query))}`,
             });
@@ -52,7 +61,7 @@ export function createDecisionsClient(config = {}) {
         /**
          * Get calibration analytics for judgment outcomes.
          */
-        async getJudgmentCalibration(query) {
+        getJudgmentCalibration(query) {
             return gateway.request({
                 path: `/api/platform/v1/graph/judgments/calibration${toQueryString(normalizeTopicQuery(query))}`,
             });
@@ -60,10 +69,12 @@ export function createDecisionsClient(config = {}) {
         /**
          * List judgments still awaiting outcome review.
          */
-        async listPendingOutcomeReviews(query) {
-            return gateway.request({
+        listPendingOutcomeReviews(query) {
+            return gateway
+                .request({
                 path: `/api/platform/v1/graph/judgments/pending-outcome-review${toQueryString(normalizeTopicQuery(query))}`,
-            }).then((response) => mapGatewayData(response, (data) => {
+            })
+                .then((response) => mapGatewayData(response, (data) => {
                 const rows = Array.isArray(data) ? data : [];
                 const reviews = rows.map((row) => withTopicAlias(row));
                 return createListResult(reviews, "reviews");
@@ -72,34 +83,32 @@ export function createDecisionsClient(config = {}) {
         /**
          * Get audit integrity checks for judgment transitions.
          */
-        async getJudgmentTransitionAuditIntegrity(query) {
+        getJudgmentTransitionAuditIntegrity(query) {
             return gateway.request({
                 path: `/api/platform/v1/graph/judgments/transition-audit-integrity${toQueryString({
                     ...normalizeTopicQuery(query),
                     judgmentId: query.judgmentId,
-                    includePassing: typeof query.includePassing === "boolean"
-                        ? query.includePassing
-                            ? "true"
-                            : "false"
-                        : undefined,
+                    includePassing: booleanQueryParam(query.includePassing),
                 })}`,
             });
         },
         /**
          * Create a judgment.
          */
-        async createJudgment(input, idempotencyKey) {
-            return gateway.request({
+        createJudgment(input, idempotencyKey) {
+            return gateway
+                .request({
                 path: "/api/platform/v1/graph/judgments",
                 method: "POST",
                 body: normalizeTopicQuery(input),
                 idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
-            }).then((response) => mapGatewayData(response, (data) => withTopicAlias(data)));
+            })
+                .then((response) => mapGatewayData(response, (data) => withTopicAlias(data)));
         },
         /**
          * Update the outcome for an existing judgment.
          */
-        async updateJudgmentOutcome(judgmentId, input, idempotencyKey) {
+        updateJudgmentOutcome(judgmentId, input, idempotencyKey) {
             return gateway.request({
                 path: `/api/platform/v1/graph/judgments/${encodeURIComponent(judgmentId)}/outcome`,
                 method: "POST",

package/dist/edges/index.d.ts

@@ -16,21 +16,21 @@ export declare function createEdgesClient(config?: EdgesClientConfig): {
         weight?: number;
         context?: string;
         reasoning?: string;
-    }, idempotencyKey?: string) => any;
+    }, idempotencyKey?: string) => Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
     listEdges: (args: {
         sourceId: string;
         edgeType?: string;
         limit?: number;
         cursor?: string;
-    }) => any;
+    }) => Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayList>>;
     traverseEdges: (args: {
         startNode: string;
         direction?: string;
         maxDepth?: number;
         topicId?: string;
-    }) => any;
-    updateEdge: (input: import("..").FunctionSurfaceInput, idempotencyKey?: string) => any;
-    removeEdge: (input: import("..").FunctionSurfaceInput, idempotencyKey?: string) => any;
+    }) => Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
+    updateEdge: (input: import("..").FunctionSurfaceInput, idempotencyKey?: string) => Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+    removeEdge: (input: import("..").FunctionSurfaceInput, idempotencyKey?: string) => Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
     raw: {
         create(args: import("..").FunctionSurfaceInput & {
             from?: unknown;
@@ -43,29 +43,31 @@ export declare function createEdgesClient(config?: EdgesClientConfig): {
             weight?: number;
             context?: string;
             reasoning?: string;
-        }, idempotencyKey?: string): any;
-        createEdge(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        update(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        updateEdge(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        remove(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeEdge(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeBetween(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        removeEdgesBetween(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreate(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreateEdges(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): any;
-        delete(input: Parameters<(...args: any[]) => any>[0], idempotencyKey?: string): any;
+        }, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        createEdge(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        update(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        updateEdge(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        remove(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        removeEdge(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        removeBetween(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        removeEdgesBetween(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        batchCreate(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        batchCreateEdges(input: import("..").FunctionSurfaceInput, idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<unknown>>;
+        delete(input: Parameters<(input: {
+            edgeIds: string[];
+        }, idempotencyKey?: string) => Promise<import("..").PlatformGatewaySuccess<import("../gatewayFacades").GatewayRecord>>>[0], idempotencyKey?: string): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
         list(args: {
             sourceId: string;
             edgeType?: string;
             limit?: number;
             cursor?: string;
-        }): any;
+        }): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayList>>;
         traverse(args: {
             startNode: string;
             direction?: string;
             maxDepth?: number;
             topicId?: string;
-        }): any;
+        }): Promise<import("../client-config").GatewayDataEnvelope<import("../gatewayFacades").GatewayRecord>>;
     };
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/edges/index.js

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/performance/noBarrelFile: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the facade/barrel export is intentional.
 import { createLucernClient } from "../client.js";
 export * as graphContracts from "@lucern/contracts/graph/v1";
 export * as methodSchemas from "@lucern/contracts/sdk-methods.contract";

package/dist/embeddingsClient.d.ts

@@ -1,54 +1,54 @@
+import { type TopicProjectAliasInput } from "./boundary-client-surface";
 import { type GatewayClientConfig } from "./coreClient";
-import { type TopicProjectAliasInput } from "./boundaryClientSurface";
 import type { JsonObject, ListResult } from "./types";
 export type EmbeddingsClientConfig = GatewayClientConfig;
 export declare const EMBEDDINGS_FIELDS: readonly ["topicId", "projectId", "workspaceId", "nodeIds", "nodeType", "embeddingModel", "includeInactive", "queryText", "queryVector", "minScore", "limit", "cursor", "metadata"];
-export type EmbeddingProvenance = {
-    sourceNodeId?: string;
+export interface EmbeddingProvenance {
+    contentHash?: string;
+    embeddedAt?: number;
+    embeddingModel?: string;
+    metadata?: JsonObject | null;
     sourceGlobalId?: string;
+    sourceNodeId?: string;
+}
+export interface EmbeddingRecord {
+    createdAt?: number;
     embeddingModel?: string;
-    embeddedAt?: number;
-    contentHash?: string;
+    globalId?: string;
+    hasEmbedding?: boolean;
     metadata?: JsonObject | null;
-};
-export type EmbeddingRecord = {
     nodeId: string;
-    globalId?: string;
+    nodeType?: string;
+    provenance?: EmbeddingProvenance;
     topicId?: string;
+    updatedAt?: number;
+    vectorDimensions?: number;
     workspaceId?: string;
-    nodeType?: string;
+}
+export interface MissingEmbeddingCandidate {
+    contentHash?: string;
     embeddingModel?: string;
-    vectorDimensions?: number;
-    hasEmbedding?: boolean;
-    provenance?: EmbeddingProvenance;
+    globalId?: string;
     metadata?: JsonObject | null;
-    createdAt?: number;
-    updatedAt?: number;
-};
-export type MissingEmbeddingCandidate = {
     nodeId: string;
-    globalId?: string;
+    nodeType?: string;
+    reason?: string;
     topicId?: string;
     workspaceId?: string;
-    nodeType?: string;
+}
+export interface VectorSearchMatch {
     embeddingModel?: string;
-    reason?: string;
-    contentHash?: string;
+    globalId?: string;
     metadata?: JsonObject | null;
-};
-export type VectorSearchMatch = {
     nodeId: string;
-    globalId?: string;
-    topicId?: string;
-    workspaceId?: string;
     nodeType?: string;
+    provenance?: EmbeddingProvenance;
     score: number;
     text?: string;
     title?: string;
-    embeddingModel?: string;
-    provenance?: EmbeddingProvenance;
-    metadata?: JsonObject | null;
-};
+    topicId?: string;
+    workspaceId?: string;
+}
 export type GetEmbeddingsByNodeIdsInput = TopicProjectAliasInput & {
     workspaceId: string;
     nodeIds: string[];

package/dist/embeddingsClient.js

@@ -1,5 +1,6 @@
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
+import { cleanRequiredString, listResultFromEnvelope, requireTopicId, topicPayload, } from "./boundary-client-surface.js";
 import { createGatewayRequestClient, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
-import { cleanRequiredString, listResultFromEnvelope, requireTopicId, topicPayload, } from "./boundaryClientSurface.js";
 import { mapGatewayData } from "./sdkSurface.js";
 export const EMBEDDINGS_FIELDS = [
     "topicId",
@@ -37,32 +38,38 @@ export function createEmbeddingsClient(config = {}) {
     return {
         getByNodeIds(input) {
             assertNodeIds(input.nodeIds);
-            return gateway.request({
+            return gateway
+                .request({
                 path: "/api/platform/v1/embeddings/by-node-ids",
                 method: "POST",
                 body: topicPayload({
                     ...input,
                     workspaceId: cleanRequiredString(input.workspaceId, "workspaceId"),
                 }, EMBEDDINGS_FIELDS, "embeddings.getByNodeIds"),
-            }).then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "embeddings")));
+            })
+                .then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "embeddings")));
         },
         listMissingForTopic(input) {
-            return gateway.request({
+            return gateway
+                .request({
                 path: `/api/platform/v1/embeddings/missing${toQueryString(missingQuery(input))}`,
-            }).then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "nodes")));
+            })
+                .then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "nodes")));
         },
         vectorSearchByTopic(input) {
-            if (!input.queryText && !input.queryVector) {
+            if (!(input.queryText || input.queryVector)) {
                 throw new Error("queryText or queryVector is required");
             }
-            return gateway.request({
+            return gateway
+                .request({
                 path: "/api/platform/v1/embeddings/vector-search",
                 method: "POST",
                 body: topicPayload({
                     ...input,
                     workspaceId: cleanRequiredString(input.workspaceId, "workspaceId"),
                 }, EMBEDDINGS_FIELDS, "embeddings.vectorSearchByTopic"),
-            }).then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "results")));
+            })
+                .then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "results")));
         },
         markEmbeddingBackfillQueued(input, idempotencyKey) {
             assertNodeIds(input.nodeIds);

package/dist/eventingClient.d.ts

@@ -3,49 +3,49 @@ import type { JsonObject, ListResult } from "./types";
 export type EventingClientConfig = GatewayClientConfig;
 export declare const EVENTING_FIELDS: readonly ["tenantId", "workspaceId", "principalId", "topicId", "eventId", "eventType", "eventPayload", "webhookId", "deliveryId", "status", "attempt", "statusCode", "error", "responseBody", "durationMs", "metadata", "limit", "cursor"];
 export type EventingStatus = "pending" | "delivering" | "succeeded" | "failed" | "dead_letter";
-export type EventingRecord = {
+export interface EventingRecord {
+    createdAt?: number;
     eventId: string;
-    tenantId: string;
-    workspaceId?: string;
-    principalId?: string;
-    topicId?: string;
-    eventType: string;
     eventPayload?: JsonObject | null;
+    eventType: string;
     metadata?: JsonObject | null;
-    createdAt?: number;
-};
-export type EventingWebhookRecord = {
-    webhookId: string;
+    principalId?: string;
     tenantId: string;
-    workspaceId?: string;
     topicId?: string;
-    url?: string;
+    workspaceId?: string;
+}
+export interface EventingWebhookRecord {
     events?: string[];
-    status?: string;
     metadata?: JsonObject | null;
-};
-export type EventingDeliveryRecord = {
-    deliveryId: string;
-    eventId?: string;
-    webhookId: string;
+    status?: string;
     tenantId: string;
+    topicId?: string;
+    url?: string;
+    webhookId: string;
     workspaceId?: string;
-    status: EventingStatus | string;
+}
+export interface EventingDeliveryRecord {
     attempt?: number;
+    deliveryId: string;
+    eventId?: string;
     metadata?: JsonObject | null;
-    updatedAt?: number;
-};
-export type EventingScope = {
+    status: EventingStatus | string;
     tenantId: string;
+    updatedAt?: number;
+    webhookId: string;
     workspaceId?: string;
+}
+export interface EventingScope {
+    cursor?: string;
+    eventType?: string;
+    limit?: number;
     principalId?: string;
+    status?: EventingStatus;
+    tenantId: string;
     topicId?: string;
-    eventType?: string;
     webhookId?: string;
-    status?: EventingStatus;
-    limit?: number;
-    cursor?: string;
-};
+    workspaceId?: string;
+}
 export type RecordEventInput = EventingScope & {
     eventId?: string;
     eventType: string;

package/dist/eventingClient.js

@@ -1,5 +1,6 @@
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
+import { cleanRequiredString, knownPayload, listResultFromEnvelope, } from "./boundary-client-surface.js";
 import { createGatewayRequestClient, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
-import { cleanRequiredString, knownPayload, listResultFromEnvelope, } from "./boundaryClientSurface.js";
 import { mapGatewayData } from "./sdkSurface.js";
 export const EVENTING_FIELDS = [
     "tenantId",
@@ -51,14 +52,18 @@ export function createEventingClient(config = {}) {
             });
         },
         listEvents(input) {
-            return gateway.request({
+            return gateway
+                .request({
                 path: `/api/platform/v1/events${toQueryString(query(input))}`,
-            }).then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "events")));
+            })
+                .then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "events")));
         },
         listWebhooks(input) {
-            return gateway.request({
+            return gateway
+                .request({
                 path: `/api/platform/v1/webhooks${toQueryString(query(input))}`,
-            }).then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "webhooks")));
+            })
+                .then((response) => mapGatewayData(response, (data) => listResultFromEnvelope(data, "webhooks")));
         },
         enqueueDelivery(input, idempotencyKey) {
             cleanRequiredString(input.tenantId, "tenantId");