@littlebigbrain/client 0.13.0 → 0.13.2

package/dist/namespaces.js

@@ -1,6 +1,7 @@
 import { attributeFilter, firstPatternVariable, parseSparqlResults, } from "./types.js";
-// SPARQL is the only query surface. The search, embedding, decode,
-// groundability, and analytics operations were removed with their routes.
+// 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.
 /** A5: fold read-consistency options into a request body's `consistency` /
  * `min_indexed_seq` fields; a per-call value wins over the client default. */
 function withReadConsistency(client, body, opts) {
@@ -23,6 +24,8 @@ export class GraphNamespace {
     query;
     schema;
     search;
+    evals;
+    embeddings;
     constructor(client) {
         this.client = client;
         this.facts = new FactsNamespace(client);
@@ -31,6 +34,8 @@ export class GraphNamespace {
         this.query = client.query;
         this.schema = client.schema;
         this.search = client.search;
+        this.evals = client.evals;
+        this.embeddings = client.embeddings;
     }
     branch(name) {
         return new GraphNamespace(this.client.withScope({ branch: name }));
@@ -135,7 +140,7 @@ export class FactsNamespace {
 }
 /**
  * Relevance-label storage. The query surfaces this namespace once fronted were
- * removed with their routes; SPARQL is the only query path now.
+ * removed with their routes; search by meaning is `embeddings.search`.
  */
 export class SearchNamespace {
     client;
@@ -199,6 +204,173 @@ export class EntityNamespace {
         });
     }
 }
+/**
+ * Search: embeddings declared on classes of the graph. The platform keeps the
+ * vectors in step with the published graph; a search checks every hit against
+ * one graph snapshot.
+ */
+export class EmbeddingsNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Every embedding of the branch with its status. */
+    list(opts = {}) {
+        return this.client.request("GET", "/v1/embeddings", opts);
+    }
+    /** One embedding: serving and building version, backfill, lag, recall. */
+    get(name, opts = {}) {
+        return this.client.request("GET", "/v1/embeddings", {
+            ...opts,
+            query: { name },
+        });
+    }
+    /**
+     * Declare or change the embedding of a class. Without `from` the server
+     * picks the fields (the label, frequent text, the names of linked
+     * entities). A new recipe builds as a new version while the old one serves.
+     */
+    declare(body, opts = {}) {
+        return this.client.request("PUT", "/v1/embeddings", { ...opts, body });
+    }
+    /**
+     * What a declaration would embed: the fields, every candidate fact of the
+     * class with its coverage and examples, and sample texts. Calls no model.
+     */
+    preview(body, opts = {}) {
+        return this.client.request("POST", "/v1/embeddings/preview", {
+            ...opts,
+            body,
+        });
+    }
+    /**
+     * Move every embedding of the graph to another model (one model per
+     * graph). Each builds a new version; the graph switches at once when
+     * every embedding has it ready, so a search never mixes two models.
+     */
+    setModel(body, opts = {}) {
+        return this.client.request("PUT", "/v1/embeddings/model", {
+            ...opts,
+            body,
+        });
+    }
+    /** Run one bounded step of the embed job now. */
+    refresh(name, opts = {}) {
+        return this.client.request("POST", "/v1/embeddings/refresh", {
+            ...opts,
+            query: { name },
+        });
+    }
+    /** Remove an embedding. */
+    delete(name, opts = {}) {
+        return this.client.request("DELETE", "/v1/embeddings", {
+            ...opts,
+            query: { name, confirm: name },
+        });
+    }
+    /**
+     * Search by meaning over every searchable class of the graph (or one
+     * `embedding`). `filter` lists the conditions every hit must meet:
+     * `{ class: iri }` (or a list; subclasses too) and
+     * `{ via: "calls", to: "payment-service", direction?: "in" }` (`to` an IRI
+     * or a name). Every hit carries its class and is checked against one
+     * graph snapshot; `include: ["text"]` returns the embedded text of each
+     * hit; `explain: true` plans without running.
+     */
+    search(body, opts = {}) {
+        return this.client.request("POST", "/v1/search", {
+            ...opts,
+            retry: opts.retry ?? true,
+            body,
+        });
+    }
+}
+/** Managed evals: traces, labels (thumbs up or down), goldens, and runs. */
+export class EvalsNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Settings, golden counts, unlabeled traces, the latest run, and the score by commit. */
+    summary(opts = {}) {
+        return this.client.request("GET", "/v1/evals", opts);
+    }
+    /** Recent traces, newest first. */
+    traces(options = {}) {
+        const { limit, unlabeled, ...opts } = options;
+        return this.client.request("GET", "/v1/evals/traces", {
+            ...opts,
+            query: { limit, unlabeled: unlabeled ? "true" : undefined },
+        });
+    }
+    /** One trace: the request, its query, its results (one item per hit or
+     * row), and their labels. */
+    trace(id, opts = {}) {
+        return this.client.request("GET", "/v1/evals/trace", {
+            ...opts,
+            query: { id },
+        });
+    }
+    /** Thumbs up or down on results of a trace: one result as `item` +
+     * `valid`, or several in `items`. The labels become the golden's ground
+     * truth. */
+    label(traceId, body, opts = {}) {
+        return this.client.request("POST", "/v1/evals/label", {
+            ...opts,
+            query: { trace: traceId },
+            body,
+        });
+    }
+    /** Let the managed judge label the results of one trace, or of a batch of
+     * traces with unlabeled results. */
+    judge(options = {}) {
+        const { traceId, limit, ...opts } = options;
+        return this.client.request("POST", "/v1/evals/judge", {
+            ...opts,
+            query: { trace: traceId, limit },
+        });
+    }
+    goldens(opts = {}) {
+        return this.client.request("GET", "/v1/evals/goldens", opts);
+    }
+    /** Freeze a query: every result it returns now is relevant. */
+    createGolden(body, opts = {}) {
+        return this.client.request("POST", "/v1/evals/goldens", { ...opts, body });
+    }
+    /** Accept the results a golden returns now as its reference. */
+    acceptGolden(id, opts = {}) {
+        return this.client.request("POST", "/v1/evals/goldens/accept", {
+            ...opts,
+            query: { id, consistency: opts.consistency },
+        });
+    }
+    deleteGolden(id, opts = {}) {
+        return this.client.request("DELETE", "/v1/evals/goldens", {
+            ...opts,
+            query: { id },
+        });
+    }
+    /** Replay every golden at the current commit. */
+    run(opts = {}) {
+        return this.client.request("POST", "/v1/evals/run", {
+            ...opts,
+            query: { consistency: opts.consistency },
+        });
+    }
+    results(options = {}) {
+        const { limit, ...opts } = options;
+        return this.client.request("GET", "/v1/evals/results", {
+            ...opts,
+            query: { limit },
+        });
+    }
+    settings(opts = {}) {
+        return this.client.request("GET", "/v1/evals/settings", opts);
+    }
+    setSettings(body, opts = {}) {
+        return this.client.request("PUT", "/v1/evals/settings", { ...opts, body });
+    }
+}
 /** Active ontology/SHACL bundle metadata and atomic publication. */
 export class SchemaNamespace {
     client;
@@ -213,6 +385,7 @@ export class SchemaNamespace {
     publish(body, opts = {}) {
         return this.client.request("POST", "/v1/schema/publish", {
             ...opts,
+            query: { dry_run: opts.dryRun },
             idempotencyKey: opts.idempotencyKey ?? this.client.idempotencyKey("schema-publish"),
             body,
         });
@@ -266,6 +439,7 @@ export class OntologyNamespace {
     evolve(body, opts = {}) {
         return this.client.request("POST", "/v1/ontology/evolve", {
             ...opts,
+            query: { dry_run: opts.dryRun },
             body,
         });
     }