@littlebigbrain/client 0.13.1 → 0.14.0

package/dist/namespaces.d.ts

@@ -9,11 +9,12 @@ export declare class GraphNamespace {
     readonly query: QueryNamespace;
     readonly schema: SchemaNamespace;
     readonly search: SearchNamespace;
+    readonly evals: EvalsNamespace;
+    readonly embeddings: EmbeddingsNamespace;
     constructor(client: LbbClient);
-    branch(name: string): GraphNamespace;
-    /** Publication lifecycle for this graph/branch, including pre-first-publish state. */
+    /** Publication lifecycle for this graph, including pre-first-publish state. */
     publicationStatus(): Promise<Schemas["PublicationStatusResponse"]>;
-    /** Wait until this graph/branch has an exact generation covering `targetSeq`. */
+    /** Wait until this graph has an exact generation covering `targetSeq`. */
     waitForPublished(targetSeq: number, opts?: {
         timeoutMs?: number;
         pollIntervalMs?: number;
@@ -22,9 +23,6 @@ export declare class GraphNamespace {
     delete(opts: {
         confirm: string;
     } & CallOptions): Promise<Schemas["GraphDeleteResponse"]>;
-    deleteBranch(opts: {
-        confirm: string;
-    } & CallOptions): Promise<Schemas["GraphBranchDeleteResponse"]>;
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body: Schemas["GraphRetractRequest"], opts?: CallOptions): Promise<Schemas["GraphRetractResponse"]>;
 }
@@ -51,7 +49,7 @@ export declare 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 declare class SearchNamespace {
     private readonly client;
@@ -86,6 +84,88 @@ export declare class EntityNamespace {
      */
     filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
 }
+/**
+ * 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 declare class EmbeddingsNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    /** Every embedding of the graph with its status. */
+    list(opts?: CallOptions): Promise<Schemas["EmbeddingListResponse"]>;
+    /** One embedding: serving and building version, backfill, lag, recall. */
+    get(name: string, opts?: CallOptions): Promise<Schemas["EmbeddingStatus"]>;
+    /**
+     * 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: Schemas["EmbeddingDeclareRequest"], opts?: CallOptions): Promise<Schemas["EmbeddingStatus"]>;
+    /**
+     * 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: Schemas["EmbeddingPreviewRequest"], opts?: CallOptions): Promise<Schemas["EmbeddingPreviewResponse"]>;
+    /**
+     * 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: Schemas["EmbeddingModelRequest"], opts?: CallOptions): Promise<Schemas["EmbeddingListResponse"]>;
+    /** Run one bounded step of the embed job now. */
+    refresh(name: string, opts?: CallOptions): Promise<Schemas["EmbeddingRefreshResponse"]>;
+    /** Remove an embedding. */
+    delete(name: string, opts?: CallOptions): Promise<unknown>;
+    /**
+     * 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: Schemas["SearchRequest"], opts?: CallOptions): Promise<Schemas["SearchResponse"]>;
+}
+/** Managed evals: traces, labels (thumbs up or down), goldens, and runs. */
+export declare class EvalsNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    /** Settings, golden counts, unlabeled traces, the latest run, and the score by commit. */
+    summary(opts?: CallOptions): Promise<Schemas["EvalSummaryResponse"]>;
+    /** Recent traces, newest first. */
+    traces(options?: {
+        limit?: number;
+        unlabeled?: boolean;
+    } & CallOptions): Promise<Schemas["EvalTraceListResponse"]>;
+    /** One trace: the request, its query, its results (one item per hit or
+     * row), and their labels. */
+    trace(id: string, opts?: CallOptions): Promise<Schemas["EvalTrace"]>;
+    /** 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: string, body: Schemas["EvalLabelRequest"], opts?: CallOptions): Promise<Schemas["EvalLabelResponse"]>;
+    /** Let the managed judge label the results of one trace, or of a batch of
+     * traces with unlabeled results. */
+    judge(options?: {
+        traceId?: string;
+        limit?: number;
+    } & CallOptions): Promise<Schemas["EvalJudgeResponse"]>;
+    goldens(opts?: CallOptions): Promise<Schemas["GoldenSuite"]>;
+    /** Freeze a query: every result it returns now is relevant. */
+    createGolden(body: Schemas["GoldenCreateRequest"], opts?: CallOptions): Promise<Schemas["GoldenResponse"]>;
+    /** Accept the results a golden returns now as its reference. */
+    acceptGolden(id: string, opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency">): Promise<Schemas["GoldenResponse"]>;
+    deleteGolden(id: string, opts?: CallOptions): Promise<Schemas["GoldenDeleteResponse"]>;
+    /** Replay every golden at the current commit. */
+    run(opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency">): Promise<Schemas["EvalRunResponse"]>;
+    results(options?: {
+        limit?: number;
+    } & CallOptions): Promise<Schemas["EvalResultsListResponse"]>;
+    settings(opts?: CallOptions): Promise<Schemas["EvalSettings"]>;
+    setSettings(body: Schemas["EvalSettings"], opts?: CallOptions): Promise<Schemas["EvalSettings"]>;
+}
 /** Active ontology/SHACL bundle metadata and atomic publication. */
 export declare class SchemaNamespace {
     private readonly client;

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,15 +34,14 @@ 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 }));
-    }
-    /** Publication lifecycle for this graph/branch, including pre-first-publish state. */
+    /** Publication lifecycle for this graph, including pre-first-publish state. */
     publicationStatus() {
         return this.client.publicationStatus();
     }
-    /** Wait until this graph/branch has an exact generation covering `targetSeq`. */
+    /** Wait until this graph has an exact generation covering `targetSeq`. */
     waitForPublished(targetSeq, opts = {}) {
         return this.client.waitForPublished(targetSeq, opts);
     }
@@ -54,13 +56,6 @@ export class GraphNamespace {
             retry: request.retry ?? true,
         });
     }
-    deleteBranch(opts) {
-        const { confirm, ...request } = opts;
-        return this.client.request("DELETE", "/v1/graph/branch", {
-            ...request,
-            query: { confirm },
-        });
-    }
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body, opts = {}) {
         return this.client.request("POST", "/v1/graph/retract", {
@@ -135,7 +130,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 +194,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 graph 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;