@littlebigbrain/client 0.14.0 → 0.16.0

package/dist/namespaces.js

@@ -1,4 +1,4 @@
-import { attributeFilter, firstPatternVariable, parseSparqlResults, } from "./types.js";
+import { attributeFilter, firstPatternVariable, parseSparqlResults, profileBody, } from "./types.js";
 // SPARQL is the query language. Search by meaning is `embeddings.search`
 // (`POST /v1/search`); the older search, embedding, decode, groundability,
 // and analytics operations were removed with their routes.
@@ -16,6 +16,9 @@ function withReadConsistency(client, body, opts) {
     }
     return merged;
 }
+function withProfile(body, opts) {
+    return profileBody(body, opts.profile);
+}
 export class GraphNamespace {
     client;
     facts;
@@ -26,6 +29,7 @@ export class GraphNamespace {
     search;
     evals;
     embeddings;
+    workflows;
     constructor(client) {
         this.client = client;
         this.facts = new FactsNamespace(client);
@@ -36,11 +40,23 @@ export class GraphNamespace {
         this.search = client.search;
         this.evals = client.evals;
         this.embeddings = client.embeddings;
+        this.workflows = client.workflows;
     }
     /** Publication lifecycle for this graph, including pre-first-publish state. */
     publicationStatus() {
         return this.client.publicationStatus();
     }
+    /** Background work on this graph. See {@link LbbClient.activity}. */
+    activity() {
+        return this.client.activity();
+    }
+    /**
+     * The SPARQL planner's statistics for the published generation latest reads
+     * use. See {@link LbbClient.plannerStats}.
+     */
+    plannerStats(opts = {}) {
+        return this.client.plannerStats(opts);
+    }
     /** Wait until this graph has an exact generation covering `targetSeq`. */
     waitForPublished(targetSeq, opts = {}) {
         return this.client.waitForPublished(targetSeq, opts);
@@ -155,16 +171,6 @@ export class EntityNamespace {
     constructor(client) {
         this.client = client;
     }
-    /**
-     * Return the exact type cardinality and a bounded deterministic sample from
-     * the Base family pinned by the published generation.
-     */
-    sample(opts) {
-        return this.client.entityTypeSample(opts);
-    }
-    get(opts) {
-        return this.client.entityMetadata(opts);
-    }
     detail(opts) {
         return this.client.entityDetail(opts);
     }
@@ -381,11 +387,105 @@ export class SchemaNamespace {
         });
     }
 }
+/**
+ * Ontology change suggestions: durable proposals from integrations,
+ * agents and people. People accept or dismiss them; accepting
+ * applies the change to the current ontology.
+ */
+export class OntologySuggestionsNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Newest update first, with counts per status over the whole graph. */
+    list(options = {}) {
+        const { status, originKind, originId, anchor, key, limit, ...opts } = options;
+        return this.client.request("GET", "/v1/ontology/suggestions", {
+            ...opts,
+            query: {
+                status,
+                origin_kind: originKind,
+                origin_id: originId,
+                anchor,
+                key,
+                limit,
+            },
+        });
+    }
+    /** One suggestion with its evidence, impact and discussion. */
+    get(suggestionId, opts = {}) {
+        return this.client.request("GET", "/v1/ontology/suggestions/detail", {
+            ...opts,
+            query: { suggestion_id: suggestionId },
+        });
+    }
+    /**
+     * File a suggestion, or update the one with the same `key`. The server
+     * dry-runs the change and never changes the ontology here, so a retry is
+     * safe.
+     */
+    create(body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions", {
+            ...opts,
+            retry: opts.retry ?? true,
+            body,
+        });
+    }
+    /** Dry-run the change against the current ontology and store the impact. */
+    validate(suggestionId, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/validate", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+        });
+    }
+    /**
+     * Apply the change to the current ontology. Pass `change` to accept an
+     * edited change. Accepting twice returns the accepted suggestion.
+     */
+    accept(suggestionId, body = {}, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/accept", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+    /** Decline with a reason. The ontology does not change. */
+    dismiss(suggestionId, body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/dismiss", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+    /** Withdraw as the producer, for example when the source field is gone. */
+    supersede(suggestionId, body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/supersede", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+    /** Add a comment to the discussion. */
+    comment(suggestionId, body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/comment", {
+            ...opts,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+}
 /** Ontology discovery and lifecycle operations. */
 export class OntologyNamespace {
     client;
+    /** Reviewable change suggestions from every producer. */
+    suggestions;
     constructor(client) {
         this.client = client;
+        this.suggestions = new OntologySuggestionsNamespace(client);
     }
     view(options = {}) {
         const { counts, ...request } = options;
@@ -394,11 +494,18 @@ export class OntologyNamespace {
             query: counts ? { counts: true } : undefined,
         });
     }
+    /**
+     * Read the published SHACL conformance report. `limit` bounds the returned
+     * `results` (server default 200, maximum 2,000); `result_count` and
+     * `conforms` stay exact, and `truncated` says the window is partial.
+     */
     conformance(opts = {}) {
+        const { limit, ...rest } = opts;
         return this.client.request("GET", "/v1/ontology/conformance", {
-            ...opts,
+            ...rest,
             query: {
                 consistency: opts.consistency ?? this.client.defaultConsistency,
+                ...(limit !== undefined ? { limit } : {}),
             },
         });
     }
@@ -433,13 +540,6 @@ export class OntologyNamespace {
             body,
         });
     }
-    induce(body, opts = {}) {
-        return this.client.request("POST", "/v1/ontology/induce", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
 }
 /** Structured and SPARQL-text query operations. */
 export class QueryNamespace {
@@ -451,15 +551,20 @@ export class QueryNamespace {
         return this.client.request("POST", "/v1/query/sparql", {
             ...opts,
             retry: opts.retry ?? true,
-            body: withReadConsistency(this.client, body, opts),
+            body: profileBody(withReadConsistency(this.client, body, opts)),
         });
     }
+    /**
+     * Run a SPARQL text query and parse its rows. `profile: true` (in `opts` or
+     * the body) returns the server's measurements in `profile`; a profiled
+     * request never uses the result cache.
+     */
     async sparql(body, opts = {}) {
         // The text dialect carries consistency/floor on the URL, not the body.
         const response = await this.client.request("POST", "/v1/query/sparql-text", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
+            body: withProfile(body, opts),
             query: {
                 consistency: opts.consistency ?? this.client.defaultConsistency,
                 min_indexed_seq: opts.minIndexedSeq,
@@ -467,11 +572,12 @@ export class QueryNamespace {
         });
         return parseSparqlResults(response);
     }
+    /** As {@link sparql}, returning the raw response with its `results` string. */
     sparqlRaw(body, opts = {}) {
         return this.client.request("POST", "/v1/query/sparql-text", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
+            body: withProfile(body, opts),
             query: {
                 consistency: opts.consistency ?? this.client.defaultConsistency,
                 min_indexed_seq: opts.minIndexedSeq,