@littlebigbrain/client 0.13.1 → 0.14.0

package/README.md

@@ -1,129 +1,144 @@
 # @littlebigbrain/client
 
-The typed TypeScript client for [Little Big Brain](https://littlebigbrain.com) — write graph facts and query one immutable published snapshot. Request and response types are generated from the API contract, so every call is fully typed. Runs anywhere there's a global `fetch`: Node 18+, browsers, and edge workers.
+TypeScript client for [little big brain](https://littlebigbrain.com), a search
+platform for AI applications such as chatbots, search tools, and agents.
+Load facts, query their relationships, and keep the data version behind an answer
+so you can check it later.
+
+The client has no runtime dependencies and includes generated request and response
+types. It uses `fetch` and supports Node.js 18+, browsers, and edge workers.
+Keep stack API keys on your server or local machine, outside browser bundles.
+
+[Documentation](https://docs.littlebigbrain.com/sdks/typescript/) ·
+[Quickstart](https://docs.littlebigbrain.com/start/quickstart/) ·
+[Issues](https://github.com/littlebigbrains/lbb-typescript/issues)
+
+## Install
 
 ```sh
 npm install @littlebigbrain/client
 ```
 
-## Quickstart
+## Load facts and run a query
+
+Create a stack in the [console](https://cloud.littlebigbrain.com) and open
+**Connect**. Copy its complete endpoint and a stack API key:
+
+```sh
+export LBB_URL="https://<your-complete-stack-host>"
+export LBB_API_KEY="<your-stack-api-key>"
+```
+
+This example creates a graph named `quickstart` on its first write. It stores
+three facts: a service writes to a database, and each has a label. The data uses
+Resource Description Framework (RDF), where each line names a subject, a
+relationship, and a value or another record. SPARQL is the query language for
+those facts.
+
+Save as `quickstart.mts`, then run `npx tsx quickstart.mts`:
 
 ```ts
 import { LbbClient } from "@littlebigbrain/client";
 
 const lbb = new LbbClient({
-  baseUrl: "https://0abc1def--production.db.eu.littlebigbrain.com",
-  apiKey: process.env.LBB_API_KEY, // lbb_sk_live_… — keep it server-side
+  baseUrl: process.env.LBB_URL!,
+  apiKey: process.env.LBB_API_KEY!,
+  graph: "quickstart",
 });
-const graph = lbb.graph("main");
-
-// 1. Write a fact.
-await graph.facts.create(
-  {
-    triplets: [
-      {
-        source: { type: "CONCEPT", name: "policy-42" },
-        relation: "RELATED_TO",
-        target: { type: "CONCEPT", name: "seven-year retention" },
-        evidence: "Customer records are retained for seven years.",
-      },
-    ],
-  },
-  { idempotencyKey: "policy-42-v1" },
-);
 
-// 2. Publication is automatic. Inspect one coherent watermark when needed.
-const published = await lbb.readSnapshot();
-console.log(published.snapshot.served_at_seq, published.query_lag_commits);
+const facts = `
+<https://example.org/auth-service> <https://example.org/writesTo> <https://example.org/user-db> .
+<https://example.org/auth-service> <http://www.w3.org/2000/01/rdf-schema#label> "Auth Service" .
+<https://example.org/user-db> <http://www.w3.org/2000/01/rdf-schema#label> "User Database" .
+`;
 
-// 3. Query the snapshot with SPARQL.
-const rows = await lbb.sparqlRows({
-  query: "SELECT ?s ?o WHERE { ?s <policy:retention> ?o } LIMIT 10",
+const imported = await lbb.graph("quickstart").facts.importRdf(facts, {
+  format: "ntriples",
+  idempotencyKey: "sdk-quickstart-v1",
 });
-```
-
-For hosted use, `baseUrl` is required and must be the exact `endpoint_url`
-shown on the stack's Connect page. Graph and branch remain client scope
-parameters; they are not encoded in the hostname.
-
-## Examples
-
-**Bulk import.** Load an array of records (or an NDJSON string) in one call:
-
-```ts
-await graph.facts.import(
-  [
-    { source: { type: "DOC", name: "handbook", key: "doc:42" }, relation: "HAS_PASSAGE", target: { type: "PASSAGE", name: "leave-policy", key: "p:42:1" } },
-    // …one record per line
-  ],
-  { idempotencyKey: "handbook-batch-1" },
+const commitSeq = imported.committed_commit_seq;
+if (commitSeq == null) throw new Error("The import did not return a commit sequence.");
+
+const query = `
+  SELECT ?service ?database WHERE {
+    ?s <https://example.org/writesTo> ?db .
+    ?s <http://www.w3.org/2000/01/rdf-schema#label> ?service .
+    ?db <http://www.w3.org/2000/01/rdf-schema#label> ?database .
+  } ORDER BY ?service ?database LIMIT 10
+`;
+
+const { rows } = await lbb.sparqlRows(
+  { query },
+  { consistency: "strong", minIndexedSeq: commitSeq },
 );
+
+for (const row of rows) console.log(`${row.service} -> ${row.database}`);
 ```
 
-For large or long-running loads, stream records to a durable job instead:
+On a fresh graph, this prints:
 
-```ts
-const accepted = await lbb.submitImport(records(), {
-  idempotencyKey: "hubspot:portal-42:run-2026-07-29",
-});
-const completed = await lbb.waitForImportJob(accepted.job_id);
-console.log(completed.state, completed.committed_commit_seq);
+```text
+Auth Service -> User Database
 ```
 
-`records()` may be an iterable or async iterable. Success means every grouped
-commit is durable and immediately queryable by a strong SPARQL read. The same
-commits advance the graph's coalesced RDF reconciliation fence; waiting for base
-compaction is optional. An empty iterable is rejected locally before an import
-POST is sent.
+The query follows the stored relationship between the service and database.
+`consistency: "strong"` makes the new facts available to this read without
+waiting for a background index job. Reads default to eventual consistency, so
+omit this option only when an earlier version is acceptable.
+
+The idempotency key makes repeating the same import safe. Use a new key if you
+change the data.
 
-For several RDF documents, `facts.importRdfMany(...)` automatically defers
-intermediate reconciliation and triggers it on the last document. Call
-`graph.waitForPublished(result.finalSequence)` only when the caller needs the
-immutable base itself to cover the import; strong reads need no waiter.
+## Read the same version again
 
-**Time-travel read.** Pin a SPARQL read to a past instant — results reflect the graph as it was then:
+Run the query at the commit returned by the import:
 
 ```ts
-const asOf = await lbb.sparqlRows({
-  query: "SELECT ?s ?o WHERE { ?s <policy:retention> ?o }",
-  as_of_valid_time: "2026-01-01T00:00:00Z",
+const replay = await lbb.sparqlRows({
+  query,
+  as_of_commit_seq: commitSeq,
 });
+console.log(replay.rows);
 ```
 
-**SPARQL.** `sparqlRows` runs a SPARQL 1.1 SELECT/ASK and returns parsed rows:
+Save the query, its options, and the commit sequence with any answer you need to
+check later. See [history and replay](https://docs.littlebigbrain.com/guides/time-travel-audit/)
+for retention and evidence handling.
 
-```ts
-const { rows } = await lbb.sparqlRows({
-  query: `SELECT ?doc WHERE { ?doc ?p ?o } LIMIT 10`,
-});
-```
+## Next steps
+
+- [Search by meaning](https://docs.littlebigbrain.com/guides/search-by-meaning/): choose which facts to embed and find records from a text description.
+- [Load your own RDF](https://docs.littlebigbrain.com/guides/load-rdf/): import Turtle, N-Triples, N-Quads, or TriG.
+- [Work with JSON records](https://docs.littlebigbrain.com/guides/without-rdf/): define a schema and write records without writing RDF.
+- [Validate writes](https://docs.littlebigbrain.com/guides/sparql-and-shacl/): define constraints with the Shapes Constraint Language (SHACL).
 
-## Errors & retries
+The RDF and JSON guides use different write workflows. Choose one when creating
+a graph; a graph first written through RDF import does not accept
+`facts.create` or JSON record imports.
 
-Methods return parsed JSON and throw `LbbError` (with `status`, `code`, `message`, `param`, `requestId`, `docUrl`) on any non-2xx response. Safe reads and idempotency-keyed writes retry `429`/`5xx` and network failures with full-jitter backoff, bounded by a retry budget (`retryBudgetMs`, default 60s) rather than a fixed count, and honor `Retry-After` — a terminal error the server marks non-retryable surfaces immediately. Use `rawRequest()` for response headers, request id, and retry/timing metadata.
-`waitForPublished(...)` is an optional, deadline-bounded maintenance poller for
-workflows that want the immutable RDF base itself to cover a commit. Strong
-SPARQL does not need it: acknowledged commits are queryable immediately from
-the branch head's base-plus-delta lineage.
+## Errors and retries
 
-## More
+Failed HTTP requests throw `LbbError`, with a status, error code, message, and
+request ID. Use `rawRequest()` when you also need response headers or timing.
 
-The `graph(...)` scope exposes `facts`, `entities`, `ontology`, `query`,
-`search` (feedback surfaces), and `schema` namespaces. `query` runs SPARQL,
-the one query language on the API; `schema`
-reads or atomically publishes the active ontology/shapes bundle. Writes enqueue
-published-generation maintenance automatically. Every generated shape is
-available as `Schemas["TypeName"]`. Retired request-time JSON SHACL DTOs are
-intentionally absent: publish RDF shapes with `schema.publish`, then read
-`ontology.conformance`.
+Safe reads and writes with an idempotency key retry rate limits, retryable server
+errors, and network failures. Retries respect `Retry-After` and use a 60-second
+budget by default. See the [client reference](https://docs.littlebigbrain.com/sdks/typescript/)
+for timeout and retry options.
 
-Full reference and guides: [docs.littlebigbrain.com/sdks/typescript](https://docs.littlebigbrain.com/sdks/typescript/).
+## Development
 
-## Develop
+From a clone of this repository:
 
 ```sh
-npm install
-npm run generate    # regenerate types from contracts/openapi.json
+npm ci
 npm run typecheck
 npm test
 ```
+
+The request and response types are generated from the API contract. See
+[CONTRIBUTING.md](CONTRIBUTING.md) for changes to generated types.
+
+## License
+
+[Apache-2.0](LICENSE).

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import type { DurableImportSource, ImportLine, LbbClientOptions, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportDocument, RdfImportManyResult, RdfImportOptions, Schemas, SearchConsistency, SparqlResults } from "./types.js";
 import { type CallOptions, type RequestOptions } from "./transport.js";
-import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace } from "./namespaces.js";
+import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, EvalsNamespace, EmbeddingsNamespace } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
 export type { AttributeFilter, AttributeFilterOp, AttributeFilterValue, EntityAttributeFilterOptions, EntityPropertiesLine, DurableImportLine, DurableImportSource, FetchLike, FlatProperties, ImportLine, LbbClientOptions, LbbRequestEvent, LbbResponseEvent, LbbRetryEvent, LbbErrorPayload, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportDocument, RdfImportManyResult, RdfImportOptions, Schemas, SearchConsistency, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, Snapshot, } from "./types.js";
 export { LbbCapabilityError, LbbError } from "./transport.js";
@@ -8,14 +8,13 @@ export type { CallOptions, Query, QueryValue, RequestOptions, } from "./transpor
 export { EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 /**
  * A typed HTTP client for a little big brain graph server. One instance is scoped to a
- * single graph/branch; construct another for a different scope. All methods
+ * single graph; construct another for a different scope. All methods
  * return the parsed JSON response and throw {@link LbbError} on failure.
  */
 export declare class LbbClient {
     private readonly baseUrl;
     private readonly apiKey?;
     private readonly graphName?;
-    private readonly branchName?;
     private readonly stack?;
     private readonly fetchImpl;
     private readonly apiVersion;
@@ -34,19 +33,19 @@ export declare class LbbClient {
     readonly schema: SchemaNamespace;
     readonly ontology: OntologyNamespace;
     readonly query: QueryNamespace;
+    readonly evals: EvalsNamespace;
+    readonly embeddings: EmbeddingsNamespace;
     constructor(options: LbbClientOptions);
     graph(name: string, opts?: {
-        branch?: string;
         stack?: string;
     }): GraphNamespace;
     /**
-     * A new client for a different graph/branch on the same server and credential.
-     * Each instance is scoped to one graph/branch, so use this to target another
+     * A new client for a different graph on the same server and credential.
+     * Each instance is scoped to one graph, so use this to target another
      * scope (e.g. creating a fresh graph) without mutating the current client.
      */
     withScope(scope: {
         graph?: string;
-        branch?: string;
         stack?: string;
     }): LbbClient;
     /**
@@ -140,8 +139,8 @@ export declare class LbbClient {
         idempotencyKey?: string;
     }): Promise<Schemas["GraphRetractResponse"]>;
     /**
-     * Create the scoped graph/branch with an empty ontology. Construct the client
-     * with the desired graph/branch first, then call `ontology.define` before
+     * Create the scoped graph with an empty ontology. Construct the client
+     * with the desired graph first, then call `ontology.define` before
      * writing typed data.
      */
     createGraph(): Promise<Schemas["CreateGraphResponse"]>;
@@ -181,33 +180,10 @@ export declare class LbbClient {
         observedAt?: string;
         idempotencyKey?: string;
     }): Promise<Schemas["GraphReloadResponse"]>;
-    /** Fork the scoped branch from an existing branch in the same graph. */
-    createBranch(body: Schemas["GraphBranchCreateRequest"]): Promise<Schemas["GraphBranchCreateResponse"]>;
-    /**
-     * Validate-then-merge: replay `from_branch`'s post-fork commits onto the
-     * SCOPED branch (its fork parent) as one new commit. A write — sends an
-     * Idempotency-Key so a retry replays instead of re-applying.
-     */
-    mergeBranch(body: Schemas["GraphBranchMergeRequest"], opts?: {
-        idempotencyKey?: string;
-    }): Promise<Schemas["GraphBranchMergeResponse"]>;
-    /**
-     * Observe: store a conversation episode verbatim as EPISODE evidence,
-     * anchor + gate extracted facts on an observe branch, and optionally
-     * auto-merge when validation is clean. Flag-gated server-side
-     * (`--enable-observe`). A write — carries an Idempotency-Key.
-     */
-    observe(body: Schemas["ObserveRequest"], opts?: {
-        idempotencyKey?: string;
-    }): Promise<Schemas["ObserveResponse"]>;
-    /** Delete the scoped graph, including every branch, feedback, and active graph-scoped job. */
+    /** Delete the scoped graph, including its feedback and active graph-scoped jobs. */
     deleteGraph(opts: {
         confirm: string;
     }): Promise<Schemas["GraphDeleteResponse"]>;
-    /** Delete only the scoped branch. The server refuses to delete a graph's final live branch. */
-    deleteBranch(opts: {
-        confirm: string;
-    }): Promise<Schemas["GraphBranchDeleteResponse"]>;
     /**
      * Captured signals by flush-seq range, oldest first — the model-training
      * feed. The `seq` on each signal is the temporal-split coordinate (train ≤ T,
@@ -283,16 +259,6 @@ export declare class LbbClient {
     externalPlannerTrace(payload: Schemas["ExternalPlannerTraceV1"], opts?: {
         idempotencyKey?: string;
     }): Promise<Schemas["SignalIngestResponse"]>;
-    /** Planner training examples at or before an optional signal split. */
-    plannerDataset(opts?: {
-        limit?: number;
-        splitSeq?: number;
-    }): Promise<Schemas["PlannerDatasetResponse"]>;
-    /** Planner preference pairs at or before an optional signal split. */
-    plannerPreferenceDataset(opts?: {
-        limit?: number;
-        splitSeq?: number;
-    }): Promise<Schemas["PlannerPreferenceDatasetResponse"]>;
     /** Suggest-ranker examples at or before an optional signal split. */
     suggestDataset(opts?: {
         limit?: number;
@@ -312,14 +278,6 @@ export declare class LbbClient {
         runId: string;
         allowRegression?: boolean;
     }): Promise<unknown>;
-    /**
-     * Promote a finished `planner_lora` training run: gated on held-out slot
-     * exactness and recorded as a `kind=planner` training run.
-     */
-    promotePlanner(opts: {
-        runId: string;
-        allowRegression?: boolean;
-    }): Promise<unknown>;
     /**
      * Append relevance labels for a set of ranked results — how little big brain
      * gathers customer-specific qrels. Grade results (3 ideal/good, 1 partial,
@@ -467,6 +425,9 @@ export declare class LbbClient {
     }): Promise<Schemas["GraphMetadataResponse"]>;
     /** Automatic publication lifecycle, available before the first generation exists. */
     publicationStatus(): Promise<Schemas["PublicationStatusResponse"]>;
+    /** The managed models the platform uses per role (embedding, judge,
+     * rewriter): the operator's catalog, or the compiled defaults. */
+    managedModels(): Promise<Schemas["ManagedModelsResponse"]>;
     /** Wait until background reconciliation folds `targetSeq` into the RDF base. */
     waitForPublished(targetSeq: number, opts?: {
         timeoutMs?: number;
@@ -484,6 +445,6 @@ export declare class LbbClient {
      * rebuild fills it.
      */
     schemaSummary(): Promise<Schemas["RdfSchemaSummaryResponse"]>;
-    /** List the graphs (and branches) under the scoped tenant. */
+    /** List the graphs under the scoped tenant. */
     listGraphs(): Promise<Schemas["GraphListResponse"]>;
 }

package/dist/client.js

@@ -1,7 +1,7 @@
 import { parseSparqlResults } from "./types.js";
 import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
 import { LbbCapabilityError } from "./transport.js";
-import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, EvalsNamespace, EmbeddingsNamespace, } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
 export { LbbCapabilityError, LbbError } from "./transport.js";
 export { EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
@@ -84,14 +84,13 @@ async function durableImportBody(source) {
 }
 /**
  * A typed HTTP client for a little big brain graph server. One instance is scoped to a
- * single graph/branch; construct another for a different scope. All methods
+ * single graph; construct another for a different scope. All methods
  * return the parsed JSON response and throw {@link LbbError} on failure.
  */
 export class LbbClient {
     baseUrl;
     apiKey;
     graphName;
-    branchName;
     stack;
     fetchImpl;
     apiVersion;
@@ -110,6 +109,8 @@ export class LbbClient {
     schema;
     ontology;
     query;
+    evals;
+    embeddings;
     constructor(options) {
         const baseUrl = options.baseUrl?.trim();
         if (!baseUrl) {
@@ -118,7 +119,6 @@ export class LbbClient {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.apiKey = options.apiKey;
         this.graphName = options.graph;
-        this.branchName = options.branch;
         this.stack = options.stack;
         this.apiVersion = options.apiVersion ?? "2026-07-23";
         this.maxRetries = options.maxRetries ?? 6;
@@ -152,17 +152,18 @@ export class LbbClient {
         this.schema = new SchemaNamespace(this);
         this.ontology = new OntologyNamespace(this);
         this.query = new QueryNamespace(this);
+        this.evals = new EvalsNamespace(this);
+        this.embeddings = new EmbeddingsNamespace(this);
     }
     graph(name, opts = {}) {
         return new GraphNamespace(this.withScope({
             graph: name,
-            branch: opts.branch ?? this.branchName,
             stack: opts.stack ?? this.stack,
         }));
     }
     /**
-     * A new client for a different graph/branch on the same server and credential.
-     * Each instance is scoped to one graph/branch, so use this to target another
+     * A new client for a different graph on the same server and credential.
+     * Each instance is scoped to one graph, so use this to target another
      * scope (e.g. creating a fresh graph) without mutating the current client.
      */
     withScope(scope) {
@@ -170,7 +171,6 @@ export class LbbClient {
             baseUrl: this.baseUrl,
             apiKey: this.apiKey,
             graph: scope.graph ?? this.graphName,
-            branch: scope.branch ?? this.branchName,
             stack: scope.stack ?? this.stack,
             fetch: this.fetchImpl,
             apiVersion: this.apiVersion,
@@ -218,8 +218,6 @@ export class LbbClient {
         const push = (key, value) => params.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
         if (this.graphName !== undefined)
             push("graph", this.graphName);
-        if (this.branchName !== undefined)
-            push("branch", this.branchName);
         if (this.stack !== undefined)
             push("stack", this.stack);
         for (const [key, value] of Object.entries(query ?? {})) {
@@ -600,8 +598,8 @@ export class LbbClient {
         });
     }
     /**
-     * Create the scoped graph/branch with an empty ontology. Construct the client
-     * with the desired graph/branch first, then call `ontology.define` before
+     * Create the scoped graph with an empty ontology. Construct the client
+     * with the desired graph first, then call `ontology.define` before
      * writing typed data.
      */
     createGraph() {
@@ -654,46 +652,13 @@ export class LbbClient {
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("reload"),
         });
     }
-    /** Fork the scoped branch from an existing branch in the same graph. */
-    createBranch(body) {
-        return this.request("POST", "/v1/graph/branch", { body });
-    }
-    /**
-     * Validate-then-merge: replay `from_branch`'s post-fork commits onto the
-     * SCOPED branch (its fork parent) as one new commit. A write — sends an
-     * Idempotency-Key so a retry replays instead of re-applying.
-     */
-    mergeBranch(body, opts = {}) {
-        return this.request("POST", "/v1/graph/branch/merge", {
-            body,
-            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("branch-merge"),
-        });
-    }
-    /**
-     * Observe: store a conversation episode verbatim as EPISODE evidence,
-     * anchor + gate extracted facts on an observe branch, and optionally
-     * auto-merge when validation is clean. Flag-gated server-side
-     * (`--enable-observe`). A write — carries an Idempotency-Key.
-     */
-    observe(body, opts = {}) {
-        return this.request("POST", "/v1/memory/observe", {
-            body,
-            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("observe"),
-        });
-    }
-    /** Delete the scoped graph, including every branch, feedback, and active graph-scoped job. */
+    /** Delete the scoped graph, including its feedback and active graph-scoped jobs. */
     deleteGraph(opts) {
         return this.request("POST", "/v1/graph/delete", {
             query: { confirm: opts.confirm },
             retry: true,
         });
     }
-    /** Delete only the scoped branch. The server refuses to delete a graph's final live branch. */
-    deleteBranch(opts) {
-        return this.request("DELETE", "/v1/graph/branch", {
-            query: { confirm: opts.confirm },
-        });
-    }
     // --- models as runs (training-run registry + eval machinery) ---
     /**
      * Captured signals by flush-seq range, oldest first — the model-training
@@ -799,18 +764,6 @@ export class LbbClient {
             ],
         }, opts);
     }
-    /** Planner training examples at or before an optional signal split. */
-    plannerDataset(opts = {}) {
-        return this.request("GET", "/v1/models/planner-dataset", {
-            query: { limit: opts.limit, split_seq: opts.splitSeq },
-        });
-    }
-    /** Planner preference pairs at or before an optional signal split. */
-    plannerPreferenceDataset(opts = {}) {
-        return this.request("GET", "/v1/models/planner-preference-dataset", {
-            query: { limit: opts.limit, split_seq: opts.splitSeq },
-        });
-    }
     /** Suggest-ranker examples at or before an optional signal split. */
     suggestDataset(opts = {}) {
         return this.request("GET", "/v1/models/suggest-dataset", {
@@ -833,15 +786,6 @@ export class LbbClient {
             query: { run_id: opts.runId, allow_regression: opts.allowRegression },
         });
     }
-    /**
-     * Promote a finished `planner_lora` training run: gated on held-out slot
-     * exactness and recorded as a `kind=planner` training run.
-     */
-    promotePlanner(opts) {
-        return this.request("POST", "/v1/models/promote-planner", {
-            query: { run_id: opts.runId, allow_regression: opts.allowRegression },
-        });
-    }
     // --- relevance feedback ---
     /**
      * Append relevance labels for a set of ranked results — how little big brain
@@ -1069,6 +1013,11 @@ export class LbbClient {
     publicationStatus() {
         return this.request("GET", "/v1/graph/publication-status");
     }
+    /** The managed models the platform uses per role (embedding, judge,
+     * rewriter): the operator's catalog, or the compiled defaults. */
+    managedModels() {
+        return this.request("GET", "/v1/managed-models");
+    }
     /** Wait until background reconciliation folds `targetSeq` into the RDF base. */
     async waitForPublished(targetSeq, opts = {}) {
         if (!Number.isSafeInteger(targetSeq) || targetSeq < 0) {
@@ -1119,7 +1068,7 @@ export class LbbClient {
     schemaSummary() {
         return this.request("GET", "/v1/graph/schema-summary");
     }
-    /** List the graphs (and branches) under the scoped tenant. */
+    /** List the graphs under the scoped tenant. */
     listGraphs() {
         return this.request("GET", "/v1/graphs");
     }