@lucern/sdk 1.0.11 → 1.0.13

package/dist/clientKnowledgeNamespaces.js

@@ -1,508 +1,508 @@
-// src/clientKnowledgeNamespaces.ts
-function createClientKnowledgeNamespaces(ctx) {
-  const {
-    accessControlClient,
-    addEvidence,
-    adminClient,
-    answersClient,
-    archiveOntologyCompat,
-    auditClient,
-    authDeviceClient,
-    beliefsClient,
-    beliefsFacade,
-    bisectConfidence,
-    buildBeliefsArchivePayload,
-    buildBeliefsRefinePayload,
-    clearRegisteredCustomTools,
-    config,
-    contextClient,
-    contradictionsFacade,
-    controlPlaneClient,
-    createContractCompat,
-    createEvidence,
-    createOntologyCompat,
-    createOntologyVersionCompat,
-    decisionsClient,
-    deprecateOntologyVersionCompat,
-    discoverEntityConnections,
-    discoverTopics,
-    edgesFacade,
-    embeddingsClient,
-    ensurePack,
-    evaluateContractCompat,
-    eventingClient,
-    eventsFacade,
-    evidenceClient,
-    evidenceFacade,
-    exposeGatewayData,
-    extensionNamespaces,
-    findContradictions,
-    functionSurfaceClient,
-    gateway,
-    getAuditTrail,
-    getConfidenceHistory,
-    getContractStatusCompat,
-    getCustomNamespace,
-    getOpinionHistory,
-    getPackInstalled,
-    graphAnalysisClient,
-    graphClient,
-    graphFacade,
-    graphRecommendationsClient,
-    graphStateClassifierClient,
-    harnessClient,
-    identityClient,
-    identityFacade,
-    invokeCustomTool,
-    jobsClient,
-    learningClient,
-    listBeliefs,
-    listContractsCompat,
-    listRegisteredCustomTools,
-    mcpClient,
-    modelRuntimeClient,
-    nodesNamespace,
-    ontologiesFacade,
-    ontologyClient,
-    ontologyLinksClient,
-    ontologyLinksNamespace,
-    orgGraphSearchClient,
-    packsClient,
-    policyClient,
-    publicationNamespace,
-    publishOntologyVersionCompat,
-    questionsFacade,
-    queryLineage,
-    randomIdempotencyKey,
-    registerCustomTool,
-    reportsClient,
-    requireBaseRate,
-    requireText,
-    requireTopicId,
-    requireTopicOrProjectId,
-    resolveCustomToolFullName,
-    resolveEffectiveOntologyCompat,
-    resolveTopicId,
-    schemaClient,
-    sdkQueryString,
-    searchBeliefs,
-    sourcesClient,
-    tasksFacade,
-    telemetryClient,
-    toolRegistryClient,
-    topicsClient,
-    topicsFacade,
-    traceEntityImpactCompat,
-    triggerBeliefReview,
-    unregisterCustomTool,
-    updateOntologyCompat,
-    webhooksFacade,
-    workflowClient,
-    worktreesFacade
-  } = ctx;
-  return {
-    events: {
-      list(query = {}) {
-        return eventsFacade.list(query).then(exposeGatewayData);
-      },
-      replay(input) {
-        return eventsFacade.replay(input).then(exposeGatewayData);
-      },
-      recordEvent: eventingClient.recordEvent,
-      listEvents: eventingClient.listEvents,
-      listWebhooks: eventingClient.listWebhooks,
-      enqueueDelivery: eventingClient.enqueueDelivery,
-      recordDeliveryAttempt: eventingClient.recordDeliveryAttempt,
-      updateDeliveryStatus: eventingClient.updateDeliveryStatus
-    },
-    beliefs: {
-      create(input) {
-        return beliefsFacade.create({
-          topicId: resolveTopicId(input),
-          text: requireText(input),
-          rationale: input.rationale,
-          worktreeId: input.worktreeId,
-          pillar: input.pillar,
-          baseRate: requireBaseRate(input),
-          sourceBeliefIds: input.sourceBeliefIds,
-          sourceType: input.sourceType,
-          beliefType: input.beliefType,
-          reversibility: input.reversibility,
-          predictionMeta: input.predictionMeta,
-          metadata: input.metadata
-        }).then(exposeGatewayData);
-      },
-      get(nodeId) {
-        return beliefsFacade.get(nodeId).then(exposeGatewayData);
-      },
-      refine(nodeId, textOrInput, rationale) {
-        const payload = buildBeliefsRefinePayload(textOrInput, rationale);
-        return beliefsFacade.refine(nodeId, payload).then(exposeGatewayData);
-      },
-      updateConfidence(nodeId, input) {
-        return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
-      },
-      modulateConfidence(nodeId, input) {
-        return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
-      },
-      updateStatus(input, idempotencyKey) {
-        return beliefsFacade.updateStatus(input, idempotencyKey).then(exposeGatewayData);
-      },
-      updateRationale(input, idempotencyKey) {
-        return beliefsFacade.updateRationale(input, idempotencyKey).then(exposeGatewayData);
-      },
-      linkBeliefs(input, idempotencyKey) {
-        return beliefsFacade.linkBeliefs(input, idempotencyKey).then(exposeGatewayData);
-      },
-      unlinkEvidence(input, idempotencyKey) {
-        return beliefsFacade.unlinkEvidence(input, idempotencyKey).then(exposeGatewayData);
-      },
-      updateCriticality(input, idempotencyKey) {
-        return beliefsFacade.updateCriticality(input, idempotencyKey).then(exposeGatewayData);
-      },
-      batchUpdateCriticality(input, idempotencyKey) {
-        return beliefsFacade.batchUpdateCriticality(input, idempotencyKey).then(exposeGatewayData);
-      },
-      reassignTopic(input, idempotencyKey) {
-        return beliefsFacade.reassignTopic(input, idempotencyKey).then(exposeGatewayData);
-      },
-      fork(nodeId, input) {
-        return beliefsFacade.fork(nodeId, {
-          text: requireText(input),
-          forkReason: input.forkReason,
-          rationale: input.rationale
-        }).then(exposeGatewayData);
-      },
-      archive(nodeId, input) {
-        const payload = buildBeliefsArchivePayload(input);
-        return beliefsFacade.archive(nodeId, payload).then(exposeGatewayData);
-      },
-      list(args) {
-        return beliefsFacade.list({
-          topicId: requireTopicId(args),
-          worktreeId: args.worktreeId,
-          status: args.status,
-          minConfidence: args.minConfidence,
-          limit: args.limit,
-          cursor: args.cursor
-        }).then(exposeGatewayData);
-      },
-      search: searchBeliefs,
-      lineage(nodeId) {
-        return beliefsFacade.lineage(nodeId).then(exposeGatewayData);
-      },
-      confidenceHistory(nodeId) {
-        return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
-      },
-      opinionHistory: getOpinionHistory,
-      createContract(nodeId, input) {
-        return beliefsFacade.createContract(nodeId, input).then(exposeGatewayData);
-      },
-      bisect(nodeId, input) {
-        return beliefsFacade.bisect(nodeId, input).then(exposeGatewayData);
-      }
-    },
-    webhooks: {
-      create(input) {
-        return webhooksFacade.create(input).then(exposeGatewayData);
-      },
-      list(query) {
-        return webhooksFacade.list(query).then(exposeGatewayData);
-      },
-      get(id) {
-        return webhooksFacade.get(id).then(exposeGatewayData);
-      },
-      update(id, input) {
-        return webhooksFacade.update(id, input).then(exposeGatewayData);
-      },
-      delete(id) {
-        return webhooksFacade.delete(id).then(exposeGatewayData);
-      },
-      test(id, input) {
-        return webhooksFacade.test(id, input).then(exposeGatewayData);
-      },
-      deliveries(id, query) {
-        return webhooksFacade.deliveries(id, query).then(exposeGatewayData);
-      },
-      health(id) {
-        return webhooksFacade.health(id).then(exposeGatewayData);
-      }
-    },
-    edges: {
-      create(args, idempotencyKey) {
-        if (args.from && args.to) {
-          return functionSurfaceClient.createEdge(args, idempotencyKey).then(exposeGatewayData);
-        }
-        if (!args.sourceId || !args.targetId) {
-          throw new Error("from/to graph refs or sourceId/targetId are required");
-        }
-        return edgesFacade.create({
-          sourceId: args.sourceId,
-          targetId: args.targetId,
-          edgeType: args.edgeType,
-          topicId: args.topicId,
-          confidence: args.confidence,
-          weight: args.weight,
-          context: args.context ?? args.reasoning
-        }).then(exposeGatewayData);
-      },
-      createEdge(input, idempotencyKey) {
-        return functionSurfaceClient.createEdge(input, idempotencyKey).then(exposeGatewayData);
-      },
-      update(input, idempotencyKey) {
-        return functionSurfaceClient.updateEdge(input, idempotencyKey).then(exposeGatewayData);
-      },
-      updateEdge(input, idempotencyKey) {
-        return functionSurfaceClient.updateEdge(input, idempotencyKey).then(exposeGatewayData);
-      },
-      remove(input, idempotencyKey) {
-        return functionSurfaceClient.removeEdge(input, idempotencyKey).then(exposeGatewayData);
-      },
-      removeEdge(input, idempotencyKey) {
-        return functionSurfaceClient.removeEdge(input, idempotencyKey).then(exposeGatewayData);
-      },
-      removeBetween(input, idempotencyKey) {
-        return functionSurfaceClient.removeEdgesBetween(input, idempotencyKey).then(exposeGatewayData);
-      },
-      removeEdgesBetween(input, idempotencyKey) {
-        return functionSurfaceClient.removeEdgesBetween(input, idempotencyKey).then(exposeGatewayData);
-      },
-      batchCreate(input, idempotencyKey) {
-        return functionSurfaceClient.batchCreateEdges(input, idempotencyKey).then(exposeGatewayData);
-      },
-      batchCreateEdges(input, idempotencyKey) {
-        return functionSurfaceClient.batchCreateEdges(input, idempotencyKey).then(exposeGatewayData);
-      },
-      delete(input, idempotencyKey) {
-        return edgesFacade.delete(input, idempotencyKey).then(exposeGatewayData);
-      },
-      list(args) {
-        return edgesFacade.list({
-          sourceId: args.sourceId,
-          edgeType: args.edgeType,
-          limit: args.limit,
-          cursor: args.cursor
-        }).then(exposeGatewayData);
-      },
-      traverse(args) {
-        return edgesFacade.traverse({
-          startNode: args.startNode,
-          direction: args.direction,
-          maxDepth: args.maxDepth,
-          topicId: args.topicId
-        }).then(exposeGatewayData);
-      }
-    },
-    evidence: {
-      create(args) {
-        return createEvidence(args).then(exposeGatewayData);
-      },
-      add: addEvidence,
-      get(evidenceId) {
-        return evidenceFacade.get(evidenceId).then(exposeGatewayData);
-      },
-      list(args) {
-        return evidenceFacade.list({
-          topicId: args.topicId,
-          targetId: args.targetId,
-          limit: args.limit,
-          cursor: args.cursor
-        }).then(exposeGatewayData);
-      },
-      search(args) {
-        const q = args.q ?? args.query;
-        if (!q) {
-          throw new Error("q is required");
-        }
-        return evidenceFacade.search({
-          q,
-          topicId: args.topicId,
-          targetId: args.targetId,
-          limit: args.limit,
-          cursor: args.cursor
-        }).then(exposeGatewayData);
-      },
-      link(args) {
-        const targetId = args.targetId ?? args.questionId ?? args.beliefId;
-        if (!targetId) {
-          throw new Error("targetId is required");
-        }
-        const targetType = typeof args.targetType === "string" ? args.targetType : args.questionId ? "question" : args.beliefId ? "belief" : void 0;
-        return evidenceFacade.link({
-          evidenceId: args.evidenceId,
-          targetId,
-          targetType,
-          weight: args.weight,
-          rationale: args.rationale
-        }).then(exposeGatewayData);
-      },
-      linkToBelief(args) {
-        return evidenceFacade.link({
-          evidenceId: args.evidenceId,
-          targetId: args.beliefId,
-          weight: args.weight,
-          rationale: args.rationale
-        }).then((response) => ({
-          ...response.data,
-          beliefId: args.beliefId
-        }));
-      },
-      classifyEvidence(beliefId, evidenceId, config2, idempotencyKey) {
-        return evidenceClient.classifyEvidence(beliefId, evidenceId, config2, idempotencyKey).then(exposeGatewayData);
-      },
-      classifyEvidenceBatch(beliefId, evidence, config2, idempotencyKey) {
-        return evidenceClient.classifyEvidenceBatch(beliefId, evidence, config2, idempotencyKey).then(exposeGatewayData);
-      },
-      updateStatus(input, idempotencyKey) {
-        return evidenceFacade.updateStatus(input, idempotencyKey).then(exposeGatewayData);
-      },
-      update(input, idempotencyKey) {
-        return evidenceFacade.update(input, idempotencyKey).then(exposeGatewayData);
-      },
-      flagIncorrect(input, idempotencyKey) {
-        return evidenceFacade.flagIncorrect(input, idempotencyKey).then(exposeGatewayData);
-      },
-      remove(input, idempotencyKey) {
-        return evidenceFacade.remove(input, idempotencyKey).then(exposeGatewayData);
-      },
-      updateVerificationStatus(input, idempotencyKey) {
-        return evidenceFacade.updateVerificationStatus(input, idempotencyKey).then(exposeGatewayData);
-      }
-    },
-    sources: {
-      upsert(input, idempotencyKey) {
-        return sourcesClient.upsert(input, idempotencyKey).then(exposeGatewayData);
-      },
-      get(sourceId) {
-        return sourcesClient.get(sourceId).then(exposeGatewayData);
-      }
-    },
-    questions: {
-      create(args) {
-        return questionsFacade.create({
-          topicId: resolveTopicId(args),
-          text: args.text,
-          priority: args.priority,
-          linkedBeliefId: args.linkedBeliefId,
-          metadata: args.metadata
-        }).then(exposeGatewayData);
-      },
-      get(questionId) {
-        return questionsFacade.get(questionId).then(exposeGatewayData);
-      },
-      refine(questionId, text, refinementReason) {
-        return questionsFacade.refine(questionId, {
-          text,
-          rationale: refinementReason
-        }).then(exposeGatewayData);
-      },
-      list(args) {
-        return questionsFacade.list({
-          topicId: requireTopicId(args),
-          status: args.status,
-          priority: args.priority,
-          worktreeId: args.worktreeId,
-          limit: args.limit,
-          cursor: args.cursor
-        }).then(exposeGatewayData);
-      },
-      updateStatus(questionId, status, rationale) {
-        return questionsFacade.updateStatus(questionId, {
-          status,
-          rationale
-        }).then(exposeGatewayData);
-      },
-      batchCreate(input, idempotencyKey) {
-        return questionsFacade.batchCreate(
-          {
-            ...input,
-            topicId: resolveTopicId(input)
-          },
-          idempotencyKey
-        ).then(exposeGatewayData);
-      },
-      add(input, idempotencyKey) {
-        return questionsFacade.add(
-          {
-            ...input,
-            topicId: resolveTopicId(input)
-          },
-          idempotencyKey
-        ).then(exposeGatewayData);
-      },
-      updatePriority(input, idempotencyKey) {
-        return questionsFacade.updatePriority(input, idempotencyKey).then(exposeGatewayData);
-      },
-      advanceToConviction(input, idempotencyKey) {
-        return questionsFacade.advanceToConviction(input, idempotencyKey).then(exposeGatewayData);
-      },
-      updateConviction(input, idempotencyKey) {
-        return questionsFacade.updateConviction(input, idempotencyKey).then(exposeGatewayData);
-      },
-      finalizeConviction(input, idempotencyKey) {
-        return questionsFacade.finalizeConviction(input, idempotencyKey).then(exposeGatewayData);
-      },
-      update(input, idempotencyKey) {
-        return questionsFacade.update(input, idempotencyKey).then(exposeGatewayData);
-      },
-      delete(input, idempotencyKey) {
-        return questionsFacade.delete(input, idempotencyKey).then(exposeGatewayData);
-      },
-      answer(questionId, input) {
-        return questionsFacade.answer(questionId, input).then(exposeGatewayData);
-      },
-      archive(questionId, reason) {
-        return questionsFacade.archive(questionId, { reason }).then(exposeGatewayData);
-      },
-      linkEvidence(args) {
-        const weight = args.weight ?? args.relevance;
-        return evidenceFacade.link({
-          evidenceId: args.evidenceId,
-          targetId: args.questionId,
-          targetType: "question",
-          weight,
-          rationale: args.rationale
-        }).then((response) => ({
-          ...response.data,
-          questionId: args.questionId,
-          relevance: weight
-        }));
-      },
-      getHighPriority(args) {
-        return questionsFacade.list({
-          topicId: requireTopicId(args),
-          status: args.includeAnswered ? void 0 : "open"
-        }).then(exposeGatewayData).then((data) => {
-          const questions = Array.isArray(data.questions) ? data.questions : [];
-          const rank = (priority) => {
-            switch (priority) {
-              case "urgent":
-                return 4;
-              case "high":
-                return 3;
-              case "medium":
-                return 2;
-              case "low":
-                return 1;
-              default:
-                return 0;
-            }
-          };
-          return {
-            questions: [...questions].sort((a, b) => rank(b.priority) - rank(a.priority)).slice(0, args.limit ?? 20)
-          };
-        });
-      },
-      async findMissing(args) {
-        return graphFacade.gaps({
-          topicId: requireTopicId(args),
-          minConfidence: args.minConfidence
-        }).then(exposeGatewayData);
-      }
-    }
-  };
+export function createClientKnowledgeNamespaces(ctx) {
+    const { accessControlClient, addEvidence, adminClient, answersClient, archiveOntologyCompat, auditClient, authDeviceClient, beliefsClient, beliefsFacade, bisectConfidence, buildBeliefsArchivePayload, buildBeliefsRefinePayload, clearRegisteredCustomTools, config, contextClient, contradictionsFacade, controlPlaneClient, createContractCompat, createEvidence, createOntologyCompat, createOntologyVersionCompat, decisionsClient, deprecateOntologyVersionCompat, discoverEntityConnections, discoverTopics, edgesFacade, embeddingsClient, ensurePack, evaluateContractCompat, eventingClient, eventsFacade, evidenceClient, evidenceFacade, exposeGatewayData, extensionNamespaces, findContradictions, functionSurfaceClient, gateway, getAuditTrail, getConfidenceHistory, getContractStatusCompat, getCustomNamespace, getOpinionHistory, getPackInstalled, graphAnalysisClient, graphClient, graphFacade, graphRecommendationsClient, graphStateClassifierClient, harnessClient, identityClient, identityFacade, invokeCustomTool, jobsClient, learningClient, listBeliefs, listContractsCompat, listRegisteredCustomTools, mcpClient, modelRuntimeClient, nodesNamespace, ontologiesFacade, ontologyClient, ontologyLinksClient, ontologyLinksNamespace, orgGraphSearchClient, packsClient, policyClient, publicationNamespace, publishOntologyVersionCompat, questionsFacade, queryLineage, randomIdempotencyKey, registerCustomTool, reportsClient, requireBaseRate, requireText, requireTopicId, requireTopicOrProjectId, resolveCustomToolFullName, resolveEffectiveOntologyCompat, resolveTopicId, schemaClient, sdkQueryString, searchBeliefs, sourcesClient, tasksFacade, telemetryClient, toolRegistryClient, topicsClient, topicsFacade, traceEntityImpactCompat, triggerBeliefReview, unregisterCustomTool, updateOntologyCompat, webhooksFacade, workflowClient, worktreesFacade, } = ctx;
+    return {
+        events: {
+            list(query = {}) {
+                return eventsFacade.list(query).then(exposeGatewayData);
+            },
+            replay(input) {
+                return eventsFacade.replay(input).then(exposeGatewayData);
+            },
+            recordEvent: eventingClient.recordEvent,
+            listEvents: eventingClient.listEvents,
+            listWebhooks: eventingClient.listWebhooks,
+            enqueueDelivery: eventingClient.enqueueDelivery,
+            recordDeliveryAttempt: eventingClient.recordDeliveryAttempt,
+            updateDeliveryStatus: eventingClient.updateDeliveryStatus,
+        },
+        beliefs: {
+            create(input) {
+                return beliefsFacade
+                    .create({
+                    topicId: resolveTopicId(input),
+                    text: requireText(input),
+                    rationale: input.rationale,
+                    worktreeId: input.worktreeId,
+                    pillar: input.pillar,
+                    baseRate: requireBaseRate(input),
+                    sourceBeliefIds: input.sourceBeliefIds,
+                    sourceType: input.sourceType,
+                    beliefType: input.beliefType,
+                    reversibility: input.reversibility,
+                    predictionMeta: input.predictionMeta,
+                    metadata: input.metadata,
+                })
+                    .then(exposeGatewayData);
+            },
+            get(nodeId) {
+                return beliefsFacade.get(nodeId).then(exposeGatewayData);
+            },
+            refine(nodeId, textOrInput, rationale) {
+                const payload = buildBeliefsRefinePayload(textOrInput, rationale);
+                return beliefsFacade.refine(nodeId, payload).then(exposeGatewayData);
+            },
+            updateConfidence(nodeId, input) {
+                return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
+            },
+            modulateConfidence(nodeId, input) {
+                return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
+            },
+            updateStatus(input, idempotencyKey) {
+                return beliefsFacade
+                    .updateStatus(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            updateRationale(input, idempotencyKey) {
+                return beliefsFacade
+                    .updateRationale(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            linkBeliefs(input, idempotencyKey) {
+                return beliefsFacade
+                    .linkBeliefs(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            unlinkEvidence(input, idempotencyKey) {
+                return beliefsFacade
+                    .unlinkEvidence(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            updateCriticality(input, idempotencyKey) {
+                return beliefsFacade
+                    .updateCriticality(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            batchUpdateCriticality(input, idempotencyKey) {
+                return beliefsFacade
+                    .batchUpdateCriticality(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            reassignTopic(input, idempotencyKey) {
+                return beliefsFacade
+                    .reassignTopic(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            fork(nodeId, input) {
+                return beliefsFacade
+                    .fork(nodeId, {
+                    text: requireText(input),
+                    forkReason: input.forkReason,
+                    rationale: input.rationale,
+                })
+                    .then(exposeGatewayData);
+            },
+            archive(nodeId, input) {
+                const payload = buildBeliefsArchivePayload(input);
+                return beliefsFacade.archive(nodeId, payload).then(exposeGatewayData);
+            },
+            list(args) {
+                return beliefsFacade
+                    .list({
+                    topicId: requireTopicId(args),
+                    worktreeId: args.worktreeId,
+                    status: args.status,
+                    minConfidence: args.minConfidence,
+                    limit: args.limit,
+                    cursor: args.cursor,
+                })
+                    .then(exposeGatewayData);
+            },
+            search: searchBeliefs,
+            lineage(nodeId) {
+                return beliefsFacade.lineage(nodeId).then(exposeGatewayData);
+            },
+            confidenceHistory(nodeId) {
+                return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
+            },
+            opinionHistory: getOpinionHistory,
+            createContract(nodeId, input) {
+                return beliefsFacade
+                    .createContract(nodeId, input)
+                    .then(exposeGatewayData);
+            },
+            bisect(nodeId, input) {
+                return beliefsFacade.bisect(nodeId, input).then(exposeGatewayData);
+            },
+        },
+        webhooks: {
+            create(input) {
+                return webhooksFacade.create(input).then(exposeGatewayData);
+            },
+            list(query) {
+                return webhooksFacade.list(query).then(exposeGatewayData);
+            },
+            get(id) {
+                return webhooksFacade.get(id).then(exposeGatewayData);
+            },
+            update(id, input) {
+                return webhooksFacade.update(id, input).then(exposeGatewayData);
+            },
+            delete(id) {
+                return webhooksFacade.delete(id).then(exposeGatewayData);
+            },
+            test(id, input) {
+                return webhooksFacade.test(id, input).then(exposeGatewayData);
+            },
+            deliveries(id, query) {
+                return webhooksFacade.deliveries(id, query).then(exposeGatewayData);
+            },
+            health(id) {
+                return webhooksFacade.health(id).then(exposeGatewayData);
+            },
+        },
+        edges: {
+            create(args, idempotencyKey) {
+                if (args.from && args.to) {
+                    return functionSurfaceClient
+                        .createEdge(args, idempotencyKey)
+                        .then(exposeGatewayData);
+                }
+                if (!args.sourceId || !args.targetId) {
+                    throw new Error("from/to graph refs or sourceId/targetId are required");
+                }
+                return edgesFacade
+                    .create({
+                    sourceId: args.sourceId,
+                    targetId: args.targetId,
+                    edgeType: args.edgeType,
+                    topicId: args.topicId,
+                    confidence: args.confidence,
+                    weight: args.weight,
+                    context: args.context ?? args.reasoning,
+                })
+                    .then(exposeGatewayData);
+            },
+            createEdge(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .createEdge(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            update(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .updateEdge(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            updateEdge(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .updateEdge(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            remove(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .removeEdge(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            removeEdge(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .removeEdge(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            removeBetween(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .removeEdgesBetween(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            removeEdgesBetween(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .removeEdgesBetween(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            batchCreate(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .batchCreateEdges(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            batchCreateEdges(input, idempotencyKey) {
+                return functionSurfaceClient
+                    .batchCreateEdges(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            delete(input, idempotencyKey) {
+                return edgesFacade.delete(input, idempotencyKey).then(exposeGatewayData);
+            },
+            list(args) {
+                return edgesFacade
+                    .list({
+                    sourceId: args.sourceId,
+                    edgeType: args.edgeType,
+                    limit: args.limit,
+                    cursor: args.cursor,
+                })
+                    .then(exposeGatewayData);
+            },
+            traverse(args) {
+                return edgesFacade
+                    .traverse({
+                    startNode: args.startNode,
+                    direction: args.direction,
+                    maxDepth: args.maxDepth,
+                    topicId: args.topicId,
+                })
+                    .then(exposeGatewayData);
+            },
+        },
+        evidence: {
+            create(args) {
+                return createEvidence(args).then(exposeGatewayData);
+            },
+            add: addEvidence,
+            get(evidenceId) {
+                return evidenceFacade.get(evidenceId).then(exposeGatewayData);
+            },
+            list(args) {
+                return evidenceFacade
+                    .list({
+                    topicId: args.topicId,
+                    targetId: args.targetId,
+                    limit: args.limit,
+                    cursor: args.cursor,
+                })
+                    .then(exposeGatewayData);
+            },
+            search(args) {
+                const q = args.q ?? args.query;
+                if (!q) {
+                    throw new Error("q is required");
+                }
+                return evidenceFacade
+                    .search({
+                    q,
+                    topicId: args.topicId,
+                    targetId: args.targetId,
+                    limit: args.limit,
+                    cursor: args.cursor,
+                })
+                    .then(exposeGatewayData);
+            },
+            link(args) {
+                const targetId = args.targetId ?? args.questionId ?? args.beliefId;
+                if (!targetId) {
+                    throw new Error("targetId is required");
+                }
+                const targetType = typeof args.targetType === "string"
+                    ? args.targetType
+                    : args.questionId
+                        ? "question"
+                        : args.beliefId
+                            ? "belief"
+                            : undefined;
+                return evidenceFacade
+                    .link({
+                    evidenceId: args.evidenceId,
+                    targetId,
+                    targetType: targetType,
+                    weight: args.weight,
+                    evidenceRelation: args.evidenceRelation,
+                    confidence: args.confidence,
+                    rationale: args.rationale,
+                })
+                    .then(exposeGatewayData);
+            },
+            linkToBelief(args) {
+                return evidenceFacade
+                    .link({
+                    evidenceId: args.evidenceId,
+                    targetId: args.beliefId,
+                    weight: args.weight,
+                    evidenceRelation: args.evidenceRelation,
+                    confidence: args.confidence,
+                    rationale: args.rationale,
+                })
+                    .then((response) => ({
+                    ...response.data,
+                    beliefId: args.beliefId,
+                }));
+            },
+            classifyEvidence(beliefId, evidenceId, config, idempotencyKey) {
+                return evidenceClient
+                    .classifyEvidence(beliefId, evidenceId, config, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            classifyEvidenceBatch(beliefId, evidence, config, idempotencyKey) {
+                return evidenceClient
+                    .classifyEvidenceBatch(beliefId, evidence, config, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            updateStatus(input, idempotencyKey) {
+                return evidenceFacade
+                    .updateStatus(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            update(input, idempotencyKey) {
+                return evidenceFacade.update(input, idempotencyKey).then(exposeGatewayData);
+            },
+            flagIncorrect(input, idempotencyKey) {
+                return evidenceFacade
+                    .flagIncorrect(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            remove(input, idempotencyKey) {
+                return evidenceFacade.remove(input, idempotencyKey).then(exposeGatewayData);
+            },
+            updateVerificationStatus(input, idempotencyKey) {
+                return evidenceFacade
+                    .updateVerificationStatus(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+        },
+        sources: {
+            upsert(input, idempotencyKey) {
+                return sourcesClient.upsert(input, idempotencyKey).then(exposeGatewayData);
+            },
+            get(sourceId) {
+                return sourcesClient.get(sourceId).then(exposeGatewayData);
+            },
+        },
+        questions: {
+            create(args) {
+                return questionsFacade
+                    .create({
+                    topicId: resolveTopicId(args),
+                    text: args.text,
+                    priority: args.priority,
+                    linkedBeliefId: args.linkedBeliefId,
+                    metadata: args.metadata,
+                })
+                    .then(exposeGatewayData);
+            },
+            get(questionId) {
+                return questionsFacade.get(questionId).then(exposeGatewayData);
+            },
+            refine(questionId, text, refinementReason) {
+                return questionsFacade
+                    .refine(questionId, {
+                    text,
+                    rationale: refinementReason,
+                })
+                    .then(exposeGatewayData);
+            },
+            list(args) {
+                return questionsFacade
+                    .list({
+                    topicId: requireTopicId(args),
+                    status: args.status,
+                    priority: args.priority,
+                    worktreeId: args.worktreeId,
+                    limit: args.limit,
+                    cursor: args.cursor,
+                })
+                    .then(exposeGatewayData);
+            },
+            updateStatus(questionId, status, rationale) {
+                return questionsFacade
+                    .updateStatus(questionId, {
+                    status,
+                    rationale,
+                })
+                    .then(exposeGatewayData);
+            },
+            batchCreate(input, idempotencyKey) {
+                return questionsFacade
+                    .batchCreate({
+                    ...input,
+                    topicId: resolveTopicId(input),
+                }, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            add(input, idempotencyKey) {
+                return questionsFacade
+                    .add({
+                    ...input,
+                    topicId: resolveTopicId(input),
+                }, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            updatePriority(input, idempotencyKey) {
+                return questionsFacade
+                    .updatePriority(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            advanceToConviction(input, idempotencyKey) {
+                return questionsFacade
+                    .advanceToConviction(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            updateConviction(input, idempotencyKey) {
+                return questionsFacade
+                    .updateConviction(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            finalizeConviction(input, idempotencyKey) {
+                return questionsFacade
+                    .finalizeConviction(input, idempotencyKey)
+                    .then(exposeGatewayData);
+            },
+            update(input, idempotencyKey) {
+                return questionsFacade.update(input, idempotencyKey).then(exposeGatewayData);
+            },
+            delete(input, idempotencyKey) {
+                return questionsFacade.delete(input, idempotencyKey).then(exposeGatewayData);
+            },
+            answer(questionId, input) {
+                return questionsFacade
+                    .answer(questionId, input)
+                    .then(exposeGatewayData);
+            },
+            archive(questionId, reason) {
+                return questionsFacade
+                    .archive(questionId, { reason })
+                    .then(exposeGatewayData);
+            },
+            linkEvidence(args) {
+                const weight = args.weight ?? args.relevance;
+                return evidenceFacade
+                    .link({
+                    evidenceId: args.evidenceId,
+                    targetId: args.questionId,
+                    targetType: "question",
+                    weight,
+                    rationale: args.rationale,
+                })
+                    .then((response) => ({
+                    ...response.data,
+                    questionId: args.questionId,
+                    relevance: weight,
+                }));
+            },
+            getHighPriority(args) {
+                return questionsFacade
+                    .list({
+                    topicId: requireTopicId(args),
+                    status: args.includeAnswered ? undefined : "open",
+                })
+                    .then(exposeGatewayData)
+                    .then((data) => {
+                    const questions = (Array.isArray(data.questions) ? data.questions : []);
+                    const rank = (priority) => {
+                        switch (priority) {
+                            case "urgent":
+                                return 4;
+                            case "high":
+                                return 3;
+                            case "medium":
+                                return 2;
+                            case "low":
+                                return 1;
+                            default:
+                                return 0;
+                        }
+                    };
+                    return {
+                        questions: [...questions]
+                            .sort((a, b) => rank(b.priority) - rank(a.priority))
+                            .slice(0, args.limit ?? 20),
+                    };
+                });
+            },
+            async findMissing(args) {
+                return graphFacade
+                    .gaps({
+                    topicId: requireTopicId(args),
+                    minConfidence: args.minConfidence,
+                })
+                    .then(exposeGatewayData);
+            },
+        },
+    };
 }
-
-export { createClientKnowledgeNamespaces };
-//# sourceMappingURL=clientKnowledgeNamespaces.js.map
 //# sourceMappingURL=clientKnowledgeNamespaces.js.map