@littlebigbrain/client 0.10.0 → 0.11.1

package/dist/namespaces.d.ts

@@ -1,25 +1,9 @@
 import type { LbbClient } from "./client.js";
 import type { CallOptions } from "./transport.js";
 import { type EntityAttributeFilterOptions, type ImportLine, type ReadConsistencyOptions, type RdfImportOptions, type Schemas } from "./types.js";
-export interface HybridSearchOptions extends CallOptions {
-    topK?: number;
-    consistency?: string;
-    /** A5 read-your-writes floor (`min_indexed_seq`): the committed sequence a
-     * write returned; under eventual, an uncovered floor yields a retryable
-     * `read_your_writes_pending` 429. */
-    minIndexedSeq?: number;
-    lexical?: boolean;
-    bm25?: boolean;
-    vector?: boolean;
-    targets?: string[];
-    profile?: string;
-    /** Opt-in impression logging for later relevance feedback. */
-    logImpression?: boolean;
-}
 export declare class GraphNamespace {
     private readonly client;
     readonly facts: FactsNamespace;
-    readonly context: ContextNamespace;
     readonly entities: EntityNamespace;
     readonly ontology: OntologyNamespace;
     readonly query: QueryNamespace;
@@ -34,32 +18,6 @@ export declare class GraphNamespace {
     deleteBranch(opts: {
         confirm: string;
     } & CallOptions): Promise<Schemas["GraphBranchDeleteResponse"]>;
-    embeddingConfig(opts?: CallOptions): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    /** List the embedding models available on this deployment. */
-    embeddingModels(opts?: CallOptions): Promise<Schemas["ManagedEmbeddingModelsResponse"]>;
-    /** Choose the model used automatically for writes and vector queries. */
-    setEmbeddingModel(modelId: string, options?: CallOptions & {
-        autoEmbedQuery?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    /** Advanced configuration escape hatch. Prefer `setEmbeddingModel`. */
-    setEmbeddingConfig(body: Schemas["ManagedEmbeddingConfigRequest"], opts?: CallOptions): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    backfillEmbeddings(options?: CallOptions & {
-        batchSize?: number;
-        limit?: number;
-        full?: boolean;
-        pollIntervalMs?: number;
-    }): Promise<Schemas["ManagedEmbeddingBackfillResponse"]>;
-    submitEmbeddingBackfill(options?: CallOptions & {
-        batchSize?: number;
-        limit?: number;
-        full?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    embeddingBackfillJob(jobId: string): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    cancelEmbeddingBackfill(jobId: string): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    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"]>;
 }
@@ -82,17 +40,16 @@ export declare class FactsNamespace {
      */
     importRdf(rdf: string, opts?: CallOptions & RdfImportOptions): Promise<Schemas["GraphRdfImportResponse"]>;
 }
+/**
+ * Relevance-label storage. The query surfaces this namespace once fronted were
+ * removed with their routes; SPARQL is the only query path now.
+ */
 export declare class SearchNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    hybrid(query: string, opts?: HybridSearchOptions): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    hybrid(body: Schemas["SemanticGraphSearchRequest"], opts?: CallOptions): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    multi(body: Schemas["HybridMultiSearchRequest"], opts?: CallOptions): Promise<Schemas["HybridMultiSearchResponse"]>;
     feedback(body: Schemas["SearchFeedbackRequest"], opts?: CallOptions): Promise<Schemas["SearchFeedbackResponse"]>;
     feedbackExport(opts?: CallOptions): Promise<Schemas["SearchFeedbackExportResponse"]>;
     feedbackSummary(opts?: CallOptions): Promise<Schemas["SearchFeedbackSummaryResponse"]>;
-    fullText(body: Schemas["FullTextSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["FullTextSearchResponse"]>;
-    vector(body: Schemas["EmbeddingSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["EmbeddingSearchResponse"]>;
 }
 export declare class EntityNamespace {
     private readonly client;
@@ -124,17 +81,6 @@ export declare class EntityNamespace {
      */
     filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
 }
-/** Grounding operations over one pinned published vocabulary. */
-export declare class ContextNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    suggest(body: Schemas["SearchSuggestRequest"], opts?: CallOptions): Promise<Schemas["SearchSuggestResponse"]>;
-    resolve(body: Schemas["ResolveTermRequest"], opts?: CallOptions): Promise<Schemas["ResolveTermResponse"]>;
-    decode(body: Schemas["DecodeRequest"], opts?: CallOptions): Promise<Schemas["DecodeResponse"]>;
-    groundability(options?: {
-        sample?: number;
-    } & CallOptions): Promise<Schemas["GroundabilityReport"]>;
-}
 /** Active ontology/SHACL bundle metadata and atomic publication. */
 export declare class SchemaNamespace {
     private readonly client;
@@ -154,16 +100,19 @@ export declare class OntologyNamespace {
     conformance(opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency">): Promise<Schemas["SchemaAuditReport"]>;
     search(body: Schemas["OntologySearchRequest"], opts?: CallOptions): Promise<Schemas["OntologySearchResponse"]>;
     resolve(body: Schemas["OntologyResolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyResolveResponse"]>;
+    /**
+     * Put the scoped graph on an imported ontology, creating the graph when it
+     * does not exist yet. Safe to repeat. See {@link LbbClient.ontologyDefine}.
+     */
     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, and analytical query operations. */
+/** Structured and SPARQL-text query operations. */
 export declare class QueryNamespace {
     private readonly client;
     constructor(client: LbbClient);
     structured(body: Schemas["SparqlSelectRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["SparqlSelectResponse"]>;
     sparql(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<import("./types.js").SparqlResults>;
     sparqlRaw(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["SparqlTextResponse"]>;
-    analytics(body: Schemas["AnalyticQueryRequest"], opts?: CallOptions): Promise<Schemas["AnalyticQueryResponse"]>;
 }

package/dist/namespaces.js

@@ -1,4 +1,6 @@
 import { attributeFilter, firstPatternVariable, parseSparqlResults, } from "./types.js";
+// SPARQL is the only query surface. The search, embedding, decode,
+// groundability, and analytics operations were removed with their routes.
 /** A5: fold read-consistency options into a request body's `consistency` /
  * `min_indexed_seq` fields; a per-call value wins over the client default. */
 function withReadConsistency(client, body, opts) {
@@ -13,20 +15,9 @@ function withReadConsistency(client, body, opts) {
     }
     return merged;
 }
-function transportOptions(options) {
-    return {
-        idempotencyKey: options.idempotencyKey,
-        timeoutMs: options.timeoutMs,
-        maxRetries: options.maxRetries,
-        retry: options.retry,
-        signal: options.signal,
-        headers: options.headers,
-    };
-}
 export class GraphNamespace {
     client;
     facts;
-    context;
     entities;
     ontology;
     query;
@@ -35,7 +26,6 @@ export class GraphNamespace {
     constructor(client) {
         this.client = client;
         this.facts = new FactsNamespace(client);
-        this.context = client.context;
         this.entities = client.entities;
         this.ontology = client.ontology;
         this.query = client.query;
@@ -63,63 +53,6 @@ export class GraphNamespace {
             query: { confirm },
         });
     }
-    embeddingConfig(opts = {}) {
-        return this.client.request("GET", "/v1/graph/embedding", opts);
-    }
-    /** List the embedding models available on this deployment. */
-    embeddingModels(opts = {}) {
-        return this.client.request("GET", "/v1/graph/embedding/models", opts);
-    }
-    /** Choose the model used automatically for writes and vector queries. */
-    setEmbeddingModel(modelId, options = {}) {
-        const { autoEmbedQuery, ...request } = options;
-        return this.client.request("POST", "/v1/graph/embedding", {
-            ...request,
-            body: {
-                model_id: modelId,
-                service: "open_router",
-                auto_embed_query: autoEmbedQuery ?? true,
-            },
-        });
-    }
-    /** Advanced configuration escape hatch. Prefer `setEmbeddingModel`. */
-    setEmbeddingConfig(body, opts = {}) {
-        return this.client.request("POST", "/v1/graph/embedding", {
-            ...opts,
-            body,
-        });
-    }
-    backfillEmbeddings(options = {}) {
-        return this.client.backfillEmbeddings({
-            batchSize: options.batchSize,
-            limit: options.limit,
-            full: options.full,
-            idempotencyKey: options.idempotencyKey,
-            timeoutMs: options.timeoutMs,
-            pollIntervalMs: options.pollIntervalMs,
-        });
-    }
-    submitEmbeddingBackfill(options = {}) {
-        return this.client.submitEmbeddingBackfill({
-            batchSize: options.batchSize,
-            limit: options.limit,
-            full: options.full,
-            idempotencyKey: options.idempotencyKey,
-        });
-    }
-    embeddingBackfillJob(jobId) {
-        return this.client.embeddingBackfillJob(jobId);
-    }
-    cancelEmbeddingBackfill(jobId) {
-        return this.client.cancelEmbeddingBackfill(jobId);
-    }
-    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", {
@@ -188,46 +121,15 @@ export class FactsNamespace {
         });
     }
 }
+/**
+ * Relevance-label storage. The query surfaces this namespace once fronted were
+ * removed with their routes; SPARQL is the only query path now.
+ */
 export class SearchNamespace {
     client;
     constructor(client) {
         this.client = client;
     }
-    hybrid(input, opts = {}) {
-        if (typeof input !== "string") {
-            const search = withReadConsistency(this.client, input.search ?? {}, {
-                consistency: opts.consistency,
-                minIndexedSeq: opts.minIndexedSeq,
-            });
-            return this.client.request("POST", "/v1/graph/search", {
-                ...transportOptions(opts),
-                retry: opts.retry ?? true,
-                body: { ...input, search },
-            });
-        }
-        return this.client.request("GET", "/v1/search", {
-            ...transportOptions(opts),
-            query: {
-                query: input,
-                top_k: opts.topK,
-                consistency: opts.consistency ?? this.client.defaultConsistency,
-                min_indexed_seq: opts.minIndexedSeq,
-                lexical: opts.lexical,
-                bm25: opts.bm25,
-                vector: opts.vector,
-                targets: opts.targets?.join(","),
-                profile: opts.profile,
-                log_impression: opts.logImpression,
-            },
-        });
-    }
-    multi(body, opts = {}) {
-        return this.client.request("POST", "/v1/search/multi", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
     feedback(body, opts = {}) {
         return this.client.request("POST", "/v1/search/feedback", {
             ...opts,
@@ -240,20 +142,6 @@ export class SearchNamespace {
     feedbackSummary(opts = {}) {
         return this.client.request("GET", "/v1/search/feedback/summary", opts);
     }
-    fullText(body, opts = {}) {
-        return this.client.request("POST", "/v1/search/full-text", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body: withReadConsistency(this.client, body, opts),
-        });
-    }
-    vector(body, opts = {}) {
-        return this.client.request("POST", "/v1/search/embedding", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body: withReadConsistency(this.client, body, opts),
-        });
-    }
 }
 export class EntityNamespace {
     client;
@@ -299,41 +187,6 @@ export class EntityNamespace {
         });
     }
 }
-/** Grounding operations over one pinned published vocabulary. */
-export class ContextNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    suggest(body, opts = {}) {
-        return this.client.request("POST", "/v1/search/suggest", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
-    resolve(body, opts = {}) {
-        return this.client.request("POST", "/v1/search/resolve-term", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
-    decode(body, opts = {}) {
-        return this.client.request("POST", "/v1/decode", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
-    groundability(options = {}) {
-        const { sample, ...request } = options;
-        return this.client.request("GET", "/v1/graph/groundability", {
-            ...request,
-            query: sample === undefined ? undefined : { sample },
-        });
-    }
-}
 /** Active ontology/SHACL bundle metadata and atomic publication. */
 export class SchemaNamespace {
     client;
@@ -388,6 +241,10 @@ export class OntologyNamespace {
             body,
         });
     }
+    /**
+     * Put the scoped graph on an imported ontology, creating the graph when it
+     * does not exist yet. Safe to repeat. See {@link LbbClient.ontologyDefine}.
+     */
     define(body, opts = {}) {
         return this.client.request("POST", "/v1/ontology/define", {
             ...opts,
@@ -408,7 +265,7 @@ export class OntologyNamespace {
         });
     }
 }
-/** Structured, SPARQL-text, and analytical query operations. */
+/** Structured and SPARQL-text query operations. */
 export class QueryNamespace {
     client;
     constructor(client) {
@@ -445,11 +302,4 @@ export class QueryNamespace {
             },
         });
     }
-    analytics(body, opts = {}) {
-        return this.client.request("POST", "/v1/query/analytics", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
 }