@littlebigbrain/client 0.13.2 → 0.15.0

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 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 { type RequestOptions } from "./transport.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";
@@ -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;
@@ -38,17 +37,15 @@ export declare class LbbClient {
     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;
     /**
@@ -142,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"]>;
@@ -183,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,
@@ -285,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;
@@ -314,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,
@@ -334,34 +290,6 @@ export declare class LbbClient {
     }): Promise<Schemas["SearchFeedbackResponse"]>;
     /** Export the stored relevance labels as qrels-style rows for training. */
     searchFeedbackExport(): Promise<Schemas["SearchFeedbackExportResponse"]>;
-    /**
-     * Ranked incoming/outgoing neighborhood for a graph entity.
-     *
-     * `edges` caps the edges returned per direction (default 1000, maximum
-     * 10000). When a cap cuts a direction the response carries a `truncation`
-     * block; an uncut response omits it entirely.
-     */
-    entityNeighborhood(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        relations?: string[];
-        asOf?: string;
-        edges?: number;
-    }): Promise<Schemas["EntityNeighborhoodResponse"]>;
-    /** Exact type cardinality plus a bounded deterministic sample from Base. */
-    entityTypeSample(opts: {
-        type: string;
-        limit?: number;
-    } & CallOptions): Promise<Schemas["EntityTypeSampleResponse"]>;
-    /** Stored entity object-ref status and index-coverage metadata (no
-     * attributes — read those from `entityDetail`'s top-level `attributes`). */
-    entityMetadata(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        asOf?: string;
-    }): Promise<Schemas["EntityMetadataResponse"]>;
     /**
      * Read projected attributes and current relationships from one RDF snapshot.
      * Inspect `unavailable_sections` before interpreting legacy provenance arrays.
@@ -385,14 +313,6 @@ export declare class LbbClient {
      * The caller supplies a bounded collection endpoint and its cursor.
      */
     listAll<T>(fetchPage: (cursor?: string) => Promise<ListResponse<T>>): AsyncGenerator<T, void, unknown>;
-    /** Current state of an entity's relations, optionally as-of a timestamp. */
-    currentState(body: Schemas["CurrentStateRequest"]): Promise<Schemas["CurrentStateResponse"]>;
-    /** Full edge-event history for a relationship. */
-    history(body: Schemas["RelationshipHistoryRequest"]): Promise<Schemas["RelationshipHistoryResponse"]>;
-    /** Ordered state-transition log for an entity's relation, with dwell time. */
-    transitions(body: Schemas["EntityTransitionsRequest"]): Promise<Schemas["EntityTransitionsResponse"]>;
-    /** Lineage and evidence for a single edge. */
-    why(body: Schemas["WhyRequest"]): Promise<Schemas["WhyResponse"]>;
     /**
      * SPARQL-subset SELECT/ASK/aggregate query (FILTER, HAVING, ORDER BY, ASK,
      * COUNT/SUM/AVG/MIN/MAX). GROUP BY is not limited to entity identity:
@@ -404,14 +324,27 @@ export declare class LbbClient {
      * `groups[].keys`.
      */
     sparql(body: Schemas["SparqlSelectRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["SparqlSelectResponse"]>;
-    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. The text dialect carries `consistency`/`min_indexed_seq` on the URL; a floor with no explicit consistency implies a strong base-plus-delta read. */
+    /**
+     * SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is
+     * SPARQL 1.1 Query Results JSON. The text dialect carries
+     * `consistency`/`min_indexed_seq` on the URL; a floor with no explicit
+     * consistency implies a strong base-plus-delta read. `as_of_commit_seq` in
+     * the body reads the retained published generation of that exact commit.
+     *
+     * The query is read-only, so a retryable `429` (for example
+     * `read_your_writes_pending` while publication catches up to the floor) is
+     * retried within the retry budget. A `5xx` is not retried: a query that
+     * timed out would run again.
+     */
     sparqlText(body: Schemas["SparqlTextRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["SparqlTextResponse"]>;
     /**
      * Run a SPARQL 1.1 text query and return parsed results — the ergonomic
      * complement to {@link sparqlText} (which hands back the raw results string).
-     * Returns `{ vars, boolean, bindings, rows }` via {@link parseSparqlResults}:
-     * `rows` is the bindings flattened to `{ variable: lexicalValue }`, `boolean`
-     * is the ASK answer (or `null` for a SELECT).
+     * Returns `{ vars, boolean, bindings, rows, snapshot }` via
+     * {@link parseSparqlResults}: `rows` is the bindings flattened to
+     * `{ variable: lexicalValue }`, `boolean` is the ASK answer (or `null` for a
+     * SELECT), and `snapshot.served_at_seq` is the commit an eventual or pinned
+     * read answered from (`snapshot` is `null` for a plain strong read).
      */
     sparqlRows(body: Schemas["SparqlTextRequest"], opts?: ReadConsistencyOptions): Promise<SparqlResults>;
     /**
@@ -489,6 +422,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,5 +1,5 @@
 import { parseSparqlResults } from "./types.js";
-import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
+import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retriesNetworkFailure, retriesStatus, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
 import { LbbCapabilityError } from "./transport.js";
 import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, EvalsNamespace, EmbeddingsNamespace, } from "./namespaces.js";
 export { parseSparqlResults } from "./types.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;
@@ -120,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;
@@ -160,13 +158,12 @@ export class LbbClient {
     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) {
@@ -174,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,
@@ -222,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 ?? {})) {
@@ -243,7 +237,7 @@ export class LbbClient {
         if (opts.idempotencyKey !== undefined)
             headers["idempotency-key"] = opts.idempotencyKey;
         Object.assign(headers, opts.headers ?? {});
-        const canRetry = opts.retry ?? retryAllowed(method, opts.idempotencyKey);
+        const retry = opts.retry ?? retryAllowed(method, opts.idempotencyKey);
         const body = opts.rawBody !== undefined
             ? opts.rawBody
             : opts.body !== undefined
@@ -308,7 +302,9 @@ export class LbbClient {
                         cause: error,
                     }), { name: "TimeoutError" })
                     : error;
-                if (!callerAborted && canRetry && attempt < maxRetries) {
+                if (!callerAborted &&
+                    retriesNetworkFailure(retry) &&
+                    attempt < maxRetries) {
                     const delayMs = fullJitterBackoffMs(this.retryDelayMs, attempt);
                     if (Date.now() + delayMs <= deadline) {
                         this.onRetry?.({
@@ -335,7 +331,7 @@ export class LbbClient {
                 attempt === maxRetries) {
                 break;
             }
-            if (!canRetry) {
+            if (!retriesStatus(retry, response.status)) {
                 break;
             }
             // Honor the server's typed body verdict: a terminal error
@@ -604,8 +600,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() {
@@ -658,46 +654,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
@@ -803,18 +766,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", {
@@ -837,15 +788,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
@@ -864,45 +806,6 @@ export class LbbClient {
     searchFeedbackExport() {
         return this.request("GET", "/v1/search/feedback/export");
     }
-    /**
-     * Ranked incoming/outgoing neighborhood for a graph entity.
-     *
-     * `edges` caps the edges returned per direction (default 1000, maximum
-     * 10000). When a cap cuts a direction the response carries a `truncation`
-     * block; an uncut response omits it entirely.
-     */
-    entityNeighborhood(opts) {
-        return this.request("GET", "/v1/graph/entity/neighborhood", {
-            query: {
-                id: opts.id,
-                type: opts.type,
-                name: opts.name,
-                relations: opts.relations?.join(","),
-                as_of: opts.asOf,
-                edges: opts.edges,
-            },
-        });
-    }
-    /** Exact type cardinality plus a bounded deterministic sample from Base. */
-    entityTypeSample(opts) {
-        const { type, limit, ...request } = opts;
-        return this.request("GET", "/v1/graph/entities/sample", {
-            ...request,
-            query: { type, limit },
-        });
-    }
-    /** Stored entity object-ref status and index-coverage metadata (no
-     * attributes — read those from `entityDetail`'s top-level `attributes`). */
-    entityMetadata(opts) {
-        return this.request("GET", "/v1/graph/entity/metadata", {
-            query: {
-                id: opts.id,
-                type: opts.type,
-                name: opts.name,
-                as_of: opts.asOf,
-            },
-        });
-    }
     /**
      * Read projected attributes and current relationships from one RDF snapshot.
      * Inspect `unavailable_sections` before interpreting legacy provenance arrays.
@@ -939,23 +842,7 @@ export class LbbClient {
             cursor = page.next_cursor;
         }
     }
-    // --- temporal / lineage / shapes ---
-    /** Current state of an entity's relations, optionally as-of a timestamp. */
-    currentState(body) {
-        return this.request("POST", "/v1/query/state", { body });
-    }
-    /** Full edge-event history for a relationship. */
-    history(body) {
-        return this.request("POST", "/v1/query/history", { body });
-    }
-    /** Ordered state-transition log for an entity's relation, with dwell time. */
-    transitions(body) {
-        return this.request("POST", "/v1/query/transitions", { body });
-    }
-    /** Lineage and evidence for a single edge. */
-    why(body) {
-        return this.request("POST", "/v1/query/why", { body });
-    }
+    // --- query ---
     /**
      * SPARQL-subset SELECT/ASK/aggregate query (FILTER, HAVING, ORDER BY, ASK,
      * COUNT/SUM/AVG/MIN/MAX). GROUP BY is not limited to entity identity:
@@ -971,19 +858,33 @@ export class LbbClient {
             body: this.mergeReadConsistency(body, opts),
         });
     }
-    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. The text dialect carries `consistency`/`min_indexed_seq` on the URL; a floor with no explicit consistency implies a strong base-plus-delta read. */
+    /**
+     * SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is
+     * SPARQL 1.1 Query Results JSON. The text dialect carries
+     * `consistency`/`min_indexed_seq` on the URL; a floor with no explicit
+     * consistency implies a strong base-plus-delta read. `as_of_commit_seq` in
+     * the body reads the retained published generation of that exact commit.
+     *
+     * The query is read-only, so a retryable `429` (for example
+     * `read_your_writes_pending` while publication catches up to the floor) is
+     * retried within the retry budget. A `5xx` is not retried: a query that
+     * timed out would run again.
+     */
     sparqlText(body, opts) {
         return this.request("POST", "/v1/query/sparql-text", {
             body,
             query: this.readConsistencyQuery(opts),
+            retry: "rate_limited",
         });
     }
     /**
      * Run a SPARQL 1.1 text query and return parsed results — the ergonomic
      * complement to {@link sparqlText} (which hands back the raw results string).
-     * Returns `{ vars, boolean, bindings, rows }` via {@link parseSparqlResults}:
-     * `rows` is the bindings flattened to `{ variable: lexicalValue }`, `boolean`
-     * is the ASK answer (or `null` for a SELECT).
+     * Returns `{ vars, boolean, bindings, rows, snapshot }` via
+     * {@link parseSparqlResults}: `rows` is the bindings flattened to
+     * `{ variable: lexicalValue }`, `boolean` is the ASK answer (or `null` for a
+     * SELECT), and `snapshot.served_at_seq` is the commit an eventual or pinned
+     * read answered from (`snapshot` is `null` for a plain strong read).
      */
     async sparqlRows(body, opts) {
         return parseSparqlResults(await this.sparqlText(body, opts));
@@ -1128,7 +1029,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");
     }

package/dist/namespaces.d.ts

@@ -12,10 +12,9 @@ export declare class GraphNamespace {
     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;
@@ -24,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"]>;
 }
@@ -65,20 +61,6 @@ export declare class SearchNamespace {
 export declare class EntityNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    /**
-     * Return the exact type cardinality and a bounded deterministic sample from
-     * the Base family pinned by the published generation.
-     */
-    sample(opts: {
-        type: string;
-        limit?: number;
-    } & CallOptions): Promise<Schemas["EntityTypeSampleResponse"]>;
-    get(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        asOf?: string;
-    }): Promise<Schemas["EntityMetadataResponse"]>;
     detail(opts: Parameters<LbbClient["entityDetail"]>[0]): Promise<Schemas["EntityDetailResponse"]>;
     /**
      * Filter entities already bound by relation patterns using typed attributes,
@@ -96,7 +78,7 @@ export declare class EntityNamespace {
 export declare class EmbeddingsNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    /** Every embedding of the branch with its status. */
+    /** 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"]>;

package/dist/namespaces.js

@@ -37,14 +37,11 @@ export class GraphNamespace {
         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);
     }
@@ -59,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", {
@@ -165,16 +155,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);
     }
@@ -214,7 +194,7 @@ export class EmbeddingsNamespace {
     constructor(client) {
         this.client = client;
     }
-    /** Every embedding of the branch with its status. */
+    /** Every embedding of the graph with its status. */
     list(opts = {}) {
         return this.client.request("GET", "/v1/embeddings", opts);
     }