@littlebigbrain/client 0.3.0 → 0.4.0

package/README.md

@@ -95,13 +95,14 @@ and `elapsedMs`.
 | Area | Methods |
 | --- | --- |
 | Write | `graph("main").facts.create` |
+| Managed embeddings | `graph("main").embeddingConfig`, `graph("main").setEmbeddingConfig`, `graph("main").backfillEmbeddings`, `graph("main").promoteEmbedding` |
 | Search | `search.hybrid`, `search.multi`, `search.fullText`, `search.vector` |
 | Context substrate | `context.ask`, `context.suggest`, `context.resolve`, `context.decode`, `context.groundability` |
 | Search feedback (training data) | `search.feedback`, `search.feedbackExport` |
 | Traversal | `traverse`, `semanticTraverse` |
 | Temporal / lineage / shapes | `currentState`, `history`, `why`, `shacl` |
 | Query | `query.sparql`, `query.structured`, `query.analytics`, `query.shacl`, `query.infer`, `query.premises` |
-| Ontology | `ontology.view`, `ontology.conformance`, `ontology.search`, `ontology.resolve`, `ontology.define`, `ontology.evolve` |
+| Ontology | `ontology.view`, `ontology.conformance`, `ontology.search`, `ontology.resolve`, `ontology.define`, `ontology.evolve`, `ontology.induce` |
 | Index lifecycle | `indexes.run`, `indexes.build`, `indexes.delta`, `indexes.gc`, `compact` |
 | Inspection | `entities.list`, `entities.filterByAttributes`, `status`, `metadata`, `summary` |
 | Schema activation | `schema.view`, `schema.preview`, `schema.publish`, `schema.audit` |

package/dist/client.d.ts

@@ -131,6 +131,17 @@ export declare class LbbClient {
     deleteGraph(opts: {
         confirm: string;
     }): Promise<unknown>;
+    embeddingConfig(): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
+    setEmbeddingConfig(body: Schemas["ManagedEmbeddingConfigRequest"]): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
+    backfillEmbeddings(opts?: {
+        batchSize?: number;
+        limit?: number;
+        full?: boolean;
+    }): Promise<Schemas["ManagedEmbeddingBackfillResponse"]>;
+    promoteEmbedding(opts: {
+        runId: string;
+        allowRegression?: boolean;
+    }): Promise<Schemas["ManagedEmbeddingPromoteResponse"]>;
     /**
      * The graph's grounding vocabulary as byte-sorted, deduped string sections —
      * the canonical input for a decoder-side automaton (FST/trie) and the
@@ -474,6 +485,8 @@ export declare class LbbClient {
      * migration is needed — and a request that changes nothing is a no-op.
      */
     evolveOntology(body: Schemas["OntologyEvolveRequest"]): Promise<Schemas["OntologyEvolveResponse"]>;
+    /** Suggest ontology additions from the current graph without mutating it. */
+    induceOntology(body: Schemas["OntologyInduceRequest"]): Promise<Schemas["OntologyInduceResponse"]>;
     /**
      * Build default ANN + BM25 indexes. With `{ background: true }` the build
      * runs detached on the server and the call returns immediately — use it for

package/dist/client.js

@@ -389,6 +389,22 @@ export class LbbClient {
             query: { confirm: opts.confirm },
         });
     }
+    embeddingConfig() {
+        return this.request("GET", "/v1/graph/embedding");
+    }
+    setEmbeddingConfig(body) {
+        return this.request("POST", "/v1/graph/embedding", { body });
+    }
+    backfillEmbeddings(opts = {}) {
+        return this.request("POST", "/v1/graph/embedding/backfill", {
+            query: { batch_size: opts.batchSize, limit: opts.limit, full: opts.full },
+        });
+    }
+    promoteEmbedding(opts) {
+        return this.request("POST", "/v1/graph/embedding/promote", {
+            query: { run_id: opts.runId, allow_regression: opts.allowRegression },
+        });
+    }
     // --- models as runs (training-run registry + eval machinery) ---
     /**
      * The graph's grounding vocabulary as byte-sorted, deduped string sections —
@@ -852,6 +868,10 @@ export class LbbClient {
     evolveOntology(body) {
         return this.request("POST", "/v1/ontology/evolve", { body });
     }
+    /** Suggest ontology additions from the current graph without mutating it. */
+    induceOntology(body) {
+        return this.request("POST", "/v1/ontology/induce", { body, retry: true });
+    }
     // --- index lifecycle ---
     /**
      * Build default ANN + BM25 indexes. With `{ background: true }` the build

package/dist/namespaces.d.ts

@@ -33,6 +33,17 @@ export declare class GraphNamespace {
     delete(opts: {
         confirm: string;
     } & CallOptions): Promise<unknown>;
+    embeddingConfig(opts?: CallOptions): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
+    setEmbeddingConfig(body: Schemas["ManagedEmbeddingConfigRequest"], opts?: CallOptions): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
+    backfillEmbeddings(options?: CallOptions & {
+        batchSize?: number;
+        limit?: number;
+        full?: boolean;
+    }): Promise<Schemas["ManagedEmbeddingBackfillResponse"]>;
+    promoteEmbedding(options: CallOptions & {
+        runId: string;
+        allowRegression?: boolean;
+    }): Promise<Schemas["ManagedEmbeddingPromoteResponse"]>;
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body: Schemas["GraphRetractRequest"], opts?: CallOptions): Promise<Schemas["GraphRetractResponse"]>;
     /** Export this graph's current snapshot as Turtle, N-Triples, TriG, or N-Quads. */
@@ -170,6 +181,7 @@ export declare class OntologyNamespace {
     resolve(body: Schemas["OntologyResolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyResolveResponse"]>;
     define(body: Schemas["OntologyDefineRequest"], opts?: CallOptions): Promise<Schemas["OntologyDefineResponse"]>;
     evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyEvolveResponse"]>;
+    induce(body: Schemas["OntologyInduceRequest"], opts?: CallOptions): Promise<Schemas["OntologyInduceResponse"]>;
 }
 /** Structured, SPARQL-text, reasoning, and analytical query operations. */
 export declare class QueryNamespace {

package/dist/namespaces.js

@@ -43,6 +43,29 @@ export class GraphNamespace {
             query: { confirm },
         });
     }
+    embeddingConfig(opts = {}) {
+        return this.client.request("GET", "/v1/graph/embedding", opts);
+    }
+    setEmbeddingConfig(body, opts = {}) {
+        return this.client.request("POST", "/v1/graph/embedding", {
+            ...opts,
+            body,
+        });
+    }
+    backfillEmbeddings(options = {}) {
+        const { batchSize, limit, full, ...request } = options;
+        return this.client.request("POST", "/v1/graph/embedding/backfill", {
+            ...request,
+            query: { batch_size: batchSize, limit, full },
+        });
+    }
+    promoteEmbedding(options) {
+        const { runId, allowRegression, ...request } = options;
+        return this.client.request("POST", "/v1/graph/embedding/promote", {
+            ...request,
+            query: { run_id: runId, allow_regression: allowRegression },
+        });
+    }
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body, opts = {}) {
         return this.client.request("POST", "/v1/graph/retract", {
@@ -413,6 +436,13 @@ export class OntologyNamespace {
             body,
         });
     }
+    induce(body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/induce", {
+            ...opts,
+            retry: opts.retry ?? true,
+            body,
+        });
+    }
 }
 /** Structured, SPARQL-text, reasoning, and analytical query operations. */
 export class QueryNamespace {

package/dist/schema.d.ts

@@ -292,6 +292,58 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/graph/embedding": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Read the graph branch's default managed embedding configuration */
+        get: operations["get_v1_graph_embedding"];
+        put?: never;
+        /** Set the graph branch's default managed embedding configuration */
+        post: operations["post_v1_graph_embedding"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/graph/embedding/backfill": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Embed the graph corpus with the managed model and rebuild the Stored ANN index */
+        post: operations["post_v1_graph_embedding_backfill"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/graph/embedding/promote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Promote a successful fine-tuned embedding run to the graph default */
+        post: operations["post_v1_graph_embedding_promote"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/graph/entities": {
         parameters: {
             query?: never;
@@ -309,6 +361,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/graph/entities/filter": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Filter entities by typed properties in one loaded snapshot */
+        post: operations["post_v1_graph_entities_filter"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/graph/entity": {
         parameters: {
             query?: never;
@@ -2560,6 +2629,26 @@ export interface components {
             removed_fields?: string[];
             type: string;
         };
+        EntityFilterRequest: {
+            /**
+             * @description Typed entity properties to return on each matched row. Empty keeps the
+             *     lean row; `"*"` or `"all"` projects every property.
+             */
+            fields?: string[];
+            /** @description Property/metadata predicate evaluated against one loaded graph snapshot. */
+            filter: components["schemas"]["SearchFilterExpr"];
+            /**
+             * @description Maximum rows returned. The response's `matched_count` still reports the
+             *     full number of matches before this limit is applied.
+             */
+            limit?: number;
+        };
+        EntityFilterResponse: {
+            entities: components["schemas"]["EntityExplorerRow"][];
+            /** @description Total entities satisfying the predicate before `limit` is applied. */
+            matched_count: number;
+            snapshot: components["schemas"]["SnapshotView"];
+        };
         EntityId: string;
         EntityMetadataResponse: {
             ann_indexed_commit_seq?: null | components["schemas"]["CommitSeq"];
@@ -3683,6 +3772,70 @@ export interface components {
         LbbErrorEnvelope: {
             error: components["schemas"]["LbbErrorBody"];
         };
+        /** @description Outcome of embedding the corpus and rebuilding its Stored ANN index. */
+        ManagedEmbeddingBackfillResponse: {
+            batches: number;
+            embedded: number;
+            entities_total: number;
+            /** Format: int64 */
+            indexed_commit_seq: number;
+            model_id: string;
+            skipped: number;
+            truncated: boolean;
+        };
+        /** @description The resolved, versioned managed embedding configuration. */
+        ManagedEmbeddingConfig: {
+            auto_embed_query: boolean;
+            base_model: string;
+            /** Format: int64 */
+            created_at_micros: number;
+            /** Format: int32 */
+            dim: number;
+            metric: components["schemas"]["VectorMetric"];
+            model_id: string;
+            run_id?: string | null;
+            source: components["schemas"]["ManagedEmbeddingSource"];
+            /** Format: int64 */
+            version: number;
+        };
+        /** @description Set the graph branch's default managed embedding model. */
+        ManagedEmbeddingConfigRequest: {
+            auto_embed_query?: boolean | null;
+            base_model?: string | null;
+            /** Format: int32 */
+            dim: number;
+            metric?: null | components["schemas"]["VectorMetric"];
+            model_id: string;
+            run_id?: string | null;
+            source?: null | components["schemas"]["ManagedEmbeddingSource"];
+        };
+        /** @description Read/set response. Legacy hash-derived graphs return `configured=false` and no config. */
+        ManagedEmbeddingConfigResponse: {
+            config?: null | components["schemas"]["ManagedEmbeddingConfig"];
+            configured: boolean;
+        };
+        /** @description Response after promoting a finished training run to the graph default. */
+        ManagedEmbeddingPromoteResponse: {
+            config: components["schemas"]["ManagedEmbeddingConfig"];
+            configured: boolean;
+            evals?: null | components["schemas"]["ManagedEmbeddingPromotionEvals"];
+            promoted_run: string;
+            registry?: unknown;
+        };
+        /** @description Quality comparison used when promoting a fine-tuned embedding run. */
+        ManagedEmbeddingPromotionEvals: {
+            allow_regression: boolean;
+            /** Format: double */
+            baseline_ndcg: number;
+            tier: string;
+            /** Format: double */
+            trained_ndcg: number;
+        };
+        /**
+         * @description Where a managed embedding model came from.
+         * @enum {string}
+         */
+        ManagedEmbeddingSource: "stock" | "fine_tuned";
         ModelArtifact: {
             blake3: string;
             /** Format: int64 */
@@ -5173,6 +5326,13 @@ export interface components {
              *     surface here. Absent for entities with no SAME_AS component.
              */
             aliases?: string[];
+            /**
+             * @description Requested entity attributes, read from the same loaded snapshot used to
+             *     rank this hit. Absent when the request did not ask for a projection.
+             */
+            attributes?: {
+                [key: string]: unknown;
+            } | null;
             entity: components["schemas"]["EntityView"];
             matched_concepts: string[];
             /** Format: float */
@@ -5693,6 +5853,12 @@ export interface components {
              */
             as_of_valid_time?: string | null;
             explain?: boolean;
+            /**
+             * @description Entity attributes to project onto each entity hit from the same graph
+             *     snapshot used for ranking. Omitted or empty keeps the lean response;
+             *     `"*"` or `"all"` returns every attribute.
+             */
+            fields?: string[];
             /** Format: int32 */
             max_hops?: number;
             ontology?: null | components["schemas"]["OntologySearchOptions"];
@@ -9523,25 +9689,13 @@ export interface operations {
             };
         };
     };
-    get_v1_graph_entities: {
+    get_v1_graph_embedding: {
         parameters: {
             query?: {
                 /** @description Graph name (default `main`) */
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
-                /** @description Search text */
-                q?: string;
-                /** @description Entity type filter */
-                type?: string;
-                /** @description Max rows */
-                limit?: string;
-                /** @description Opaque cursor from the previous page */
-                cursor?: string;
-                /** @description Comma-separated property names to inline on each row (typed, native JSON); `*` for all. Omit for the lean default row. */
-                fields?: string;
-                /** @description Comma-separated entity ids to fetch in one call (bulk lookup); bypasses the q/type browse filters. */
-                ids?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-06-22` for this beta-breaking shape. */
@@ -9562,7 +9716,725 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": Record<string, never>;
+                    "application/json": components["schemas"]["ManagedEmbeddingConfigResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
+    post_v1_graph_embedding: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-06-22` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+                /** @description Stable client-generated key for safely retrying mutations. Required for fact commits. */
+                "Idempotency-Key"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ManagedEmbeddingConfigRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedEmbeddingConfigResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
+    post_v1_graph_embedding_backfill: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+                /** @description Embedding batch size (default 128, max 512) */
+                batch_size?: string;
+                /** @description Maximum entities to consider (default 100000) */
+                limit?: string;
+                /** @description Re-embed all entities instead of only new entities */
+                full?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-06-22` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+                /** @description Stable client-generated key for safely retrying mutations. Required for fact commits. */
+                "Idempotency-Key"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedEmbeddingBackfillResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
+    post_v1_graph_embedding_promote: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+                /** @description Finished training run identifier */
+                run_id?: string;
+                /** @description Allow promotion when evaluation quality regressed */
+                allow_regression?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-06-22` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+                /** @description Stable client-generated key for safely retrying mutations. Required for fact commits. */
+                "Idempotency-Key"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedEmbeddingPromoteResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
+    get_v1_graph_entities: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+                /** @description Search text */
+                q?: string;
+                /** @description Entity type filter */
+                type?: string;
+                /** @description Max rows */
+                limit?: string;
+                /** @description Opaque cursor from the previous page */
+                cursor?: string;
+                /** @description Comma-separated property names to inline on each row (typed, native JSON); `*` for all. Omit for the lean default row. */
+                fields?: string;
+                /** @description Comma-separated entity ids to fetch in one call (bulk lookup); bypasses the q/type browse filters. */
+                ids?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-06-22` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": Record<string, never>;
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
+    post_v1_graph_entities_filter: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-06-22` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+                /** @description Stable client-generated key for safely retrying mutations. Required for fact commits. */
+                "Idempotency-Key"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EntityFilterRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EntityFilterResponse"];
                 };
             };
             /** @description Bad request */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@littlebigbrain/client",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "TypeScript client for the little big brain graph + hybrid search HTTP API",
   "license": "Apache-2.0",
   "repository": {