@lucern/sdk 1.0.29 → 1.0.30

package/dist/client-assembly-types.d.ts

@@ -0,0 +1,219 @@
+import type { createAccessControlClient } from "./accessControl";
+import type { createAdminClient } from "./adminClient";
+import type { createAnswersClient } from "./answers-client";
+import type { createAudiencesClient } from "./audiences-client";
+import type { createAuditClient } from "./audit-client";
+import type { createAuthDeviceClient } from "./authDeviceClient";
+import type { createBeliefsClient } from "./beliefsClient";
+import type { CustomToolInput, CustomToolNamespace, GatewayDataEnvelope, LucernClientConfig } from "./client-config";
+import type { EvidenceCompatInput } from "./client-evidence-compat";
+import type { buildBeliefsArchivePayload, buildBeliefsRefinePayload, requireBaseRate, requireText, requireTopicId, requireTopicOrProjectId, resolveCustomToolFullName, sdkQueryString } from "./clientHelpers";
+import type { exposeGatewayData } from "./clientRuntime";
+import type { createContextClient } from "./contextClient";
+import type { createControlPlaneClient } from "./control-plane";
+import type { GatewayHttpMethod, PlatformGatewaySuccess, randomIdempotencyKey } from "./coreClient";
+import type { clearRegisteredCustomTools, listRegisteredCustomTools, registerCustomTool, unregisterCustomTool } from "./customTools";
+import type { createDecisionsClient } from "./decisionsClient";
+import type { createEmbeddingsClient } from "./embeddingsClient";
+import type { createEventingClient } from "./eventingClient";
+import type { createEvidenceClient } from "./evidenceClient";
+import type { createBeliefsFacade, createContradictionsFacade, createEdgesFacade, createEventsFacade, createEvidenceFacade, createGraphFacade, createIdentityFacade, createOntologiesFacade, createQuestionsFacade, createSearchFacade, createTasksFacade, createTopicsFacade, createWebhooksFacade, createWorktreesFacade } from "./gatewayFacades";
+import type { createFunctionSurfaceClient, FunctionSurfaceInput } from "./generated/functionSurface";
+import type { createGraphAnalysisClient } from "./graphAnalysisClient";
+import type { createGraphClient } from "./graphClient";
+import type { createGraphRecommendationsClient } from "./graphRecommendationsClient";
+import type { createGraphStateClassifierClient } from "./graphStateClassifierClient";
+import type { createHarnessClient } from "./harnessClient";
+import type { createIdentityClient } from "./identityClient";
+import type { createJobsClient } from "./jobsClient";
+import type { createLearningClient } from "./learningClient";
+import type { createMcpClient } from "./mcpClient";
+import type { createModelRuntimeClient } from "./modelRuntimeClient";
+import type { createOntologyClient } from "./ontologyClient";
+import type { createOntologyLinksClient } from "./ontologyLinksClient";
+import type { createOrgGraphSearchClient } from "./orgGraphSearchClient";
+import type { createPacksClient } from "./packsClient";
+import type { createPolicyClient } from "./policyClient";
+import type { createReportsClient } from "./reports-client";
+import type { createSchemaClient } from "./schema-client";
+import type { resolveTopicId } from "./sdkSurface";
+import type { createSourcesClient } from "./sources-client";
+import type { createTelemetryClient } from "./telemetry-client";
+import type { createToolRegistryClient } from "./toolRegistryClient";
+import type { createTopicsClient } from "./topicsClient";
+import type { JsonObject } from "./types";
+import type { createWorkflowClient } from "./workflowClient";
+export interface GatewayRequestInput {
+    body?: unknown;
+    idempotencyKey?: string;
+    method?: GatewayHttpMethod;
+    path: string;
+    requestId?: string;
+    timeoutMs?: number;
+}
+export interface GatewayRequester {
+    request<T = unknown>(input: GatewayRequestInput): Promise<PlatformGatewaySuccess<T>>;
+}
+type GatewayRecordEnvelope = GatewayDataEnvelope<Record<string, unknown>>;
+type GatewayRecordMethod<Args extends unknown[] = [JsonObject?]> = (...args: Args) => Promise<GatewayRecordEnvelope>;
+export type ClientGraphClient = ReturnType<typeof createGraphClient>;
+export type ClientFunctionSurfaceClient = ReturnType<typeof createFunctionSurfaceClient>;
+export type ClientFunctionSurfaceMethodName = keyof ClientFunctionSurfaceClient;
+export type ClientFunctionSurfaceEnvelopeMethod<Method extends ClientFunctionSurfaceMethodName> = ClientFunctionSurfaceClient[Method] extends (input?: FunctionSurfaceInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<infer Data>> ? (input: FunctionSurfaceInput, idempotencyKey?: string) => Promise<GatewayDataEnvelope<Data>> : never;
+export interface NodeListByTopicAndTypeInput {
+    cursor?: string;
+    limit?: number;
+    nodeType?: string;
+    nodeTypes?: string[];
+    projectId?: string;
+    query?: string;
+    sourceText?: string;
+    topicId?: string;
+}
+export interface NodeCountByTopicAndTypeInput {
+    limit?: number;
+    nodeType?: string;
+    nodeTypes?: string[];
+    projectId?: string;
+    query?: string;
+    topicId?: string;
+}
+export interface AuditTrailEntry {
+    action: string;
+    actor: string;
+    after: unknown;
+    before: unknown;
+    rationale: string;
+    timestamp: number;
+}
+export interface ClientNodesNamespace {
+    archive: ClientFunctionSurfaceEnvelopeMethod<"archiveEpistemicNode">;
+    batchCreate: ClientFunctionSurfaceEnvelopeMethod<"batchCreateEpistemicNodes">;
+    batchCreateEpistemicNodes: ClientFunctionSurfaceEnvelopeMethod<"batchCreateEpistemicNodes">;
+    countByTopicAndType: GatewayRecordMethod<[NodeCountByTopicAndTypeInput]>;
+    create: ClientFunctionSurfaceEnvelopeMethod<"createEpistemicNode">;
+    createEpistemicNode: ClientFunctionSurfaceEnvelopeMethod<"createEpistemicNode">;
+    get(input: string | Parameters<ClientGraphClient["getNode"]>[0]): ReturnType<ClientGraphClient["getNode"]>;
+    hardDelete: ClientGraphClient["hardDeleteNode"];
+    list: ClientGraphClient["listNodes"];
+    listByTopicAndType: GatewayRecordMethod<[NodeListByTopicAndTypeInput]>;
+    supersede: ClientFunctionSurfaceEnvelopeMethod<"supersedeEpistemicNode">;
+    update: ClientFunctionSurfaceEnvelopeMethod<"updateEpistemicNode">;
+    updateEpistemicNode: ClientFunctionSurfaceEnvelopeMethod<"updateEpistemicNode">;
+    verify: ClientFunctionSurfaceEnvelopeMethod<"verifyEpistemicNode">;
+}
+export interface LocalHelperSurface {
+    addEvidence: GatewayRecordMethod<[EvidenceCompatInput]>;
+    archiveOntologyCompat: GatewayRecordMethod<[JsonObject?]>;
+    bisectConfidence: GatewayRecordMethod<[JsonObject]>;
+    createContractCompat: GatewayRecordMethod<[JsonObject?]>;
+    createEvidence: GatewayRecordMethod<[EvidenceCompatInput]>;
+    createOntologyCompat: GatewayRecordMethod<[JsonObject?]>;
+    createOntologyVersionCompat: GatewayRecordMethod<[JsonObject?]>;
+    deprecateOntologyVersionCompat: GatewayRecordMethod<[JsonObject?]>;
+    discoverEntityConnections: GatewayRecordMethod<[JsonObject?]>;
+    discoverTopics: GatewayRecordMethod<[JsonObject?]>;
+    evaluateContractCompat: GatewayRecordMethod<[JsonObject?]>;
+    extensionNamespaces: Record<string, CustomToolNamespace>;
+    findContradictions: GatewayRecordMethod<[JsonObject]>;
+    getAuditTrail: (nodeId: string, limit?: number) => Promise<{
+        entries: AuditTrailEntry[];
+    }>;
+    getConfidenceHistory: GatewayRecordMethod<[string]>;
+    getContractStatusCompat: GatewayRecordMethod<[JsonObject?]>;
+    getCustomNamespace: (namespace: string) => CustomToolNamespace;
+    getOpinionHistory: GatewayRecordMethod<[string]>;
+    invokeCustomTool: (fullName: string, input?: CustomToolInput) => Promise<unknown>;
+    listBeliefs: GatewayRecordMethod<[JsonObject]>;
+    listContractsCompat: GatewayRecordMethod<[JsonObject?]>;
+    nodesNamespace: ClientNodesNamespace;
+    ontologyLinksNamespace: {
+        [methodName: string]: unknown;
+    };
+    publicationNamespace: {
+        [methodName: string]: unknown;
+    };
+    publishOntologyVersionCompat: GatewayRecordMethod<[JsonObject?]>;
+    queryLineage: GatewayRecordMethod<[string, number?]>;
+    resolveEffectiveOntologyCompat: GatewayRecordMethod<[JsonObject?]>;
+    searchBeliefs: GatewayRecordMethod<[JsonObject]>;
+    searchResources: GatewayRecordMethod<[JsonObject]>;
+    traceEntityImpactCompat: GatewayRecordMethod<[JsonObject]>;
+    triggerBeliefReview: GatewayRecordMethod<[JsonObject?]>;
+    updateOntologyCompat: GatewayRecordMethod<[JsonObject?]>;
+}
+export type ClientLocalHelperContext = Pick<ClientNamespaceContext, "auditClient" | "beliefsFacade" | "customNamespaceCache" | "evidenceFacade" | "exposeGatewayData" | "functionSurfaceClient" | "gateway" | "graphClient" | "graphFacade" | "ontologyClient" | "ontologyLinksClient" | "searchFacade">;
+export interface ClientNamespaceContext extends LocalHelperSurface {
+    accessControlClient: ReturnType<typeof createAccessControlClient>;
+    adminClient: ReturnType<typeof createAdminClient>;
+    answersClient: ReturnType<typeof createAnswersClient>;
+    audiencesClient: ReturnType<typeof createAudiencesClient>;
+    auditClient: ReturnType<typeof createAuditClient>;
+    authDeviceClient: ReturnType<typeof createAuthDeviceClient>;
+    beliefsClient: ReturnType<typeof createBeliefsClient>;
+    beliefsFacade: ReturnType<typeof createBeliefsFacade>;
+    buildBeliefsArchivePayload: typeof buildBeliefsArchivePayload;
+    buildBeliefsRefinePayload: typeof buildBeliefsRefinePayload;
+    clearRegisteredCustomTools: typeof clearRegisteredCustomTools;
+    config: LucernClientConfig;
+    contextClient: ReturnType<typeof createContextClient>;
+    contradictionsFacade: ReturnType<typeof createContradictionsFacade>;
+    controlPlaneClient: ReturnType<typeof createControlPlaneClient>;
+    customNamespaceCache: Map<string, CustomToolNamespace>;
+    decisionsClient: ReturnType<typeof createDecisionsClient>;
+    edgesFacade: ReturnType<typeof createEdgesFacade>;
+    embeddingsClient: ReturnType<typeof createEmbeddingsClient>;
+    ensurePack: () => Promise<void>;
+    eventingClient: ReturnType<typeof createEventingClient>;
+    eventsFacade: ReturnType<typeof createEventsFacade>;
+    evidenceClient: ReturnType<typeof createEvidenceClient>;
+    evidenceFacade: ReturnType<typeof createEvidenceFacade>;
+    exposeGatewayData: typeof exposeGatewayData;
+    functionSurfaceClient: ReturnType<typeof createFunctionSurfaceClient>;
+    gateway: GatewayRequester;
+    getPackInstalled: () => boolean;
+    graphAnalysisClient: ReturnType<typeof createGraphAnalysisClient>;
+    graphClient: ReturnType<typeof createGraphClient>;
+    graphFacade: ReturnType<typeof createGraphFacade>;
+    graphRecommendationsClient: ReturnType<typeof createGraphRecommendationsClient>;
+    graphStateClassifierClient: ReturnType<typeof createGraphStateClassifierClient>;
+    harnessClient: ReturnType<typeof createHarnessClient>;
+    identityClient: ReturnType<typeof createIdentityClient>;
+    identityFacade: ReturnType<typeof createIdentityFacade>;
+    jobsClient: ReturnType<typeof createJobsClient>;
+    learningClient: ReturnType<typeof createLearningClient>;
+    listRegisteredCustomTools: typeof listRegisteredCustomTools;
+    mcpClient: ReturnType<typeof createMcpClient>;
+    modelRuntimeClient: ReturnType<typeof createModelRuntimeClient>;
+    ontologiesFacade: ReturnType<typeof createOntologiesFacade>;
+    ontologyClient: ReturnType<typeof createOntologyClient>;
+    ontologyLinksClient: ReturnType<typeof createOntologyLinksClient>;
+    orgGraphSearchClient: ReturnType<typeof createOrgGraphSearchClient>;
+    packsClient: ReturnType<typeof createPacksClient>;
+    policyClient: ReturnType<typeof createPolicyClient>;
+    questionsFacade: ReturnType<typeof createQuestionsFacade>;
+    randomIdempotencyKey: typeof randomIdempotencyKey;
+    registerCustomTool: typeof registerCustomTool;
+    reportsClient: ReturnType<typeof createReportsClient>;
+    requireBaseRate: typeof requireBaseRate;
+    requireText: typeof requireText;
+    requireTopicId: typeof requireTopicId;
+    requireTopicOrProjectId: typeof requireTopicOrProjectId;
+    resolveCustomToolFullName: typeof resolveCustomToolFullName;
+    resolveTopicId: typeof resolveTopicId;
+    schemaClient: ReturnType<typeof createSchemaClient>;
+    sdkQueryString: typeof sdkQueryString;
+    searchFacade: ReturnType<typeof createSearchFacade>;
+    sourcesClient: ReturnType<typeof createSourcesClient>;
+    tasksFacade: ReturnType<typeof createTasksFacade>;
+    telemetryClient: ReturnType<typeof createTelemetryClient>;
+    toolRegistryClient: ReturnType<typeof createToolRegistryClient>;
+    topicsClient: ReturnType<typeof createTopicsClient>;
+    topicsFacade: ReturnType<typeof createTopicsFacade>;
+    unregisterCustomTool: typeof unregisterCustomTool;
+    webhooksFacade: ReturnType<typeof createWebhooksFacade>;
+    workflowClient: ReturnType<typeof createWorkflowClient>;
+    worktreesFacade: ReturnType<typeof createWorktreesFacade>;
+}
+export {};
+//# sourceMappingURL=client-assembly-types.d.ts.map

package/dist/client-assembly-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client-assembly-types.js.map

package/dist/{clientConfig.d.ts → client-config.d.ts}

@@ -1,16 +1,16 @@
 import type { AdminClientConfig } from "./adminClient";
-import type { AnswersClientConfig } from "./answersClient";
-import type { AudiencesClientConfig } from "./audiencesClient";
-import type { AuditClientConfig } from "./auditClient";
-import type { BeliefsClientConfig } from "./beliefsClient";
+import type { AnswersClientConfig } from "./answers-client";
+import type { AudiencesClientConfig } from "./audiences-client";
+import type { AuditClientConfig } from "./audit-client";
+import type { BeliefsClientConfig, CreateBeliefInput } from "./beliefsClient";
 import type { ContextClientConfig } from "./contextClient";
 import type { ControlPlaneIdentityClientConfig } from "./control-plane";
+import type { GatewayClientConfig, PlatformGatewaySuccess } from "./coreClient";
 import type { DecisionsClientConfig } from "./decisionsClient";
 import type { EmbeddingsClientConfig } from "./embeddingsClient";
 import type { EventingClientConfig } from "./eventingClient";
 import type { EvidenceClientConfig } from "./evidenceClient";
 import type { FunctionSurfaceClientConfig } from "./generated/functionSurface";
-import type { GatewayClientConfig, PlatformGatewaySuccess } from "./coreClient";
 import type { GraphAnalysisClientConfig } from "./graphAnalysisClient";
 import type { GraphClientConfig } from "./graphClient";
 import type { GraphRecommendationsClientConfig } from "./graphRecommendationsClient";
@@ -25,44 +25,28 @@ import type { OntologyLinksClientConfig } from "./ontologyLinksClient";
 import type { OrgGraphSearchClientConfig } from "./orgGraphSearchClient";
 import type { PacksClientConfig } from "./packsClient";
 import type { PolicyClientConfig } from "./policyClient";
-import type { ReportsClientConfig } from "./reportsClient";
-import type { SchemaClientConfig } from "./schemaClient";
-import type { SourcesClientConfig } from "./sourcesClient";
-import type { TelemetryClientConfig } from "./telemetryClient";
+import type { ReportsClientConfig } from "./reports-client";
+import type { SchemaClientConfig } from "./schema-client";
+import type { SourcesClientConfig } from "./sources-client";
+import type { TelemetryClientConfig } from "./telemetry-client";
 import type { ToolRegistryClientConfig } from "./toolRegistryClient";
 import type { TopicsClientConfig } from "./topicsClient";
-import type { JsonObject } from "./types";
 import type { WorkflowClientConfig } from "./workflowClient";
 export type ClientConfig = BeliefsClientConfig | SourcesClientConfig | GraphClientConfig | DecisionsClientConfig | AnswersClientConfig | ContextClientConfig | WorkflowClientConfig | AuditClientConfig | AdminClientConfig | EvidenceClientConfig | EmbeddingsClientConfig | EventingClientConfig | GraphAnalysisClientConfig | GraphRecommendationsClientConfig | GraphStateClassifierClientConfig | IdentityClientConfig | JobsClientConfig | ModelRuntimeClientConfig | OntologyLinksClientConfig | OrgGraphSearchClientConfig | PolicyClientConfig | PacksClientConfig | ReportsClientConfig | LearningClientConfig | TelemetryClientConfig | ToolRegistryClientConfig | FunctionSurfaceClientConfig | ControlPlaneIdentityClientConfig | OntologyClientConfig | HarnessClientConfig | SchemaClientConfig | AudiencesClientConfig | TopicsClientConfig | GatewayClientConfig;
 export type CustomToolInput = import("./clientHelpers").CustomToolInput;
 export type CustomToolInvoker = (input?: CustomToolInput) => Promise<unknown>;
 export type CustomToolNamespace = Record<string, CustomToolInvoker>;
 export type GatewayDataEnvelope<T = unknown> = PlatformGatewaySuccess<T> & (T extends Record<string, unknown> ? T : Record<string, unknown>);
-export type BeliefsCompatCreateInput = {
-    topicId?: string;
-    text?: string;
-    canonicalText?: string;
+export type BeliefsCompatCreateInput = CreateBeliefInput;
+export interface BeliefsCompatForkInput {
+    forkMode?: "supersede" | "branch";
+    forkReason: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse";
     formulation?: string;
+    newFormulation?: string;
     rationale?: string;
-    worktreeId?: string;
-    pillar?: string;
-    baseRate?: number;
-    sourceBeliefIds?: string[];
-    sourceType?: string;
-    beliefType?: string;
-    reversibility?: string;
-    predictionMeta?: JsonObject;
-    metadata?: JsonObject;
-};
-export type BeliefsCompatForkInput = {
     text?: string;
-    newFormulation?: string;
-    formulation?: string;
-    forkReason: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse";
-    forkMode?: "supersede" | "branch";
     triggeringEvidenceId: string;
-    rationale?: string;
-};
+}
 /**
  * Configuration for the high-level Lucern SDK client.
  *
@@ -93,4 +77,4 @@ export type LucernClientConfig = ClientConfig & {
     /** Target environment. Defaults to production if not specified. */
     environment?: "sandbox" | "production";
 };
-//# sourceMappingURL=clientConfig.d.ts.map
+//# sourceMappingURL=client-config.d.ts.map

package/dist/client-config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client-config.js.map

package/dist/{clientEvidenceCompat.d.ts → client-evidence-compat.d.ts}

@@ -1,16 +1,6 @@
 import type { PlatformGatewaySuccess } from "./coreClient";
 import type { JsonObject } from "./types";
-export type EvidenceCompatInput = {
-    text?: string;
-    canonicalText?: string;
-    topicId?: string;
-    source?: string;
-    sourceUrl?: string;
-    externalSourceUrl?: string;
-    targetId?: string;
-    weight?: number;
-    evidenceRelation?: "supports" | "contradicts";
-    confidence?: number;
+export interface EvidenceCompatInput {
     beliefRelations?: Array<{
         beliefId?: string;
         beliefNodeId?: string;
@@ -21,27 +11,37 @@ export type EvidenceCompatInput = {
         weight?: number;
         rationale?: string;
     }>;
-    metadata?: JsonObject;
-    title?: string;
+    canonicalText?: string;
+    confidence?: number;
     content?: string;
     contentType?: string;
-    kind?: string;
-    tags?: string[];
-    sourceType?: string;
+    evidenceRelation?: "supports" | "contradicts";
     externalSourceType?: string;
-    sourceQuestionId?: string;
-    methodology?: string;
+    externalSourceUrl?: string;
     informationAsymmetry?: string;
-    sourceQuality?: "primary" | "analyzed" | "secondary" | "tertiary" | "unknown";
-    sourceDescription?: string;
+    kind?: string;
+    metadata?: JsonObject;
+    methodology?: string;
     rationale?: string;
+    source?: string;
+    sourceDescription?: string;
+    sourceQuality?: "primary" | "analyzed" | "secondary" | "tertiary" | "unknown";
+    sourceQuestionId?: string;
+    sourceType?: string;
+    sourceUrl?: string;
     supports?: {
         nodeId: string;
         weight: number;
         reasoning?: string;
     };
-};
-type EvidenceFacadeLike = {
+    tags?: string[];
+    targetId?: string;
+    text?: string;
+    title?: string;
+    topicId?: string;
+    weight?: number;
+}
+interface EvidenceFacadeLike {
     create(args: {
         topicId?: string;
         text: string;
@@ -78,8 +78,8 @@ type EvidenceFacadeLike = {
     }): Promise<PlatformGatewaySuccess<{
         edgeId?: string;
     }>>;
-};
+}
 export declare function createEvidenceCompat(evidenceFacade: EvidenceFacadeLike, args: EvidenceCompatInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
 export declare function addEvidenceCompat(evidenceFacade: EvidenceFacadeLike, args: EvidenceCompatInput): Promise<Record<string, unknown>>;
 export {};
-//# sourceMappingURL=clientEvidenceCompat.d.ts.map
+//# sourceMappingURL=client-evidence-compat.d.ts.map

package/dist/{clientEvidenceCompat.js → client-evidence-compat.js}

@@ -1,5 +1,5 @@
 import { resolveText, resolveTopicId } from "./sdkSurface.js";
-export async function createEvidenceCompat(evidenceFacade, args) {
+export function createEvidenceCompat(evidenceFacade, args) {
     const text = resolveText(args);
     if (!text) {
         throw new Error("text is required");
@@ -56,4 +56,4 @@ export async function addEvidenceCompat(evidenceFacade, args) {
     });
     return created.data;
 }
-//# sourceMappingURL=clientEvidenceCompat.js.map
+//# sourceMappingURL=client-evidence-compat.js.map