@hydradb/sdk 2.0.1 → 2.1.0

package/dist/Client.d.ts

@@ -1,7 +1,6 @@
 import * as HydraDB from "./api/index.js";
 import { ContextClient } from "./api/resources/context/client/Client.js";
-import { EmbeddingsClient } from "./api/resources/embeddings/client/Client.js";
-import { TenantsClient } from "./api/resources/tenants/client/Client.js";
+import { DatabasesClient } from "./api/resources/databases/client/Client.js";
 import { WebhooksClient } from "./api/resources/webhooks/client/Client.js";
 import type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
 import { type NormalizedClientOptionsWithAuth } from "./BaseClient.js";
@@ -14,16 +13,14 @@ export declare namespace HydraDBClient {
 export declare class HydraDBClient {
     protected readonly _options: NormalizedClientOptionsWithAuth<HydraDBClient.Options>;
     protected _context: ContextClient | undefined;
-    protected _tenants: TenantsClient | undefined;
-    protected _embeddings: EmbeddingsClient | undefined;
+    protected _databases: DatabasesClient | undefined;
     protected _webhooks: WebhooksClient | undefined;
     constructor(options: HydraDBClient.Options);
     get context(): ContextClient;
-    get tenants(): TenantsClient;
-    get embeddings(): EmbeddingsClient;
+    get databases(): DatabasesClient;
     get webhooks(): WebhooksClient;
     /**
-     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text)
+     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids.
      *
      * @param {HydraDB.SearchQueryRequest} request
      * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/Client.js

@@ -37,9 +37,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HydraDBClient = void 0;
 const HydraDB = __importStar(require("./api/index.js"));
 const Client_js_1 = require("./api/resources/context/client/Client.js");
-const Client_js_2 = require("./api/resources/embeddings/client/Client.js");
-const Client_js_3 = require("./api/resources/tenants/client/Client.js");
-const Client_js_4 = require("./api/resources/webhooks/client/Client.js");
+const Client_js_2 = require("./api/resources/databases/client/Client.js");
+const Client_js_3 = require("./api/resources/webhooks/client/Client.js");
 const BaseClient_js_1 = require("./BaseClient.js");
 const headers_js_1 = require("./core/headers.js");
 const core = __importStar(require("./core/index.js"));
@@ -54,17 +53,14 @@ class HydraDBClient {
     get context() {
         return (this._context ?? (this._context = new Client_js_1.ContextClient(this._options)));
     }
-    get tenants() {
-        return (this._tenants ?? (this._tenants = new Client_js_3.TenantsClient(this._options)));
-    }
-    get embeddings() {
-        return (this._embeddings ?? (this._embeddings = new Client_js_2.EmbeddingsClient(this._options)));
+    get databases() {
+        return (this._databases ?? (this._databases = new Client_js_2.DatabasesClient(this._options)));
     }
     get webhooks() {
-        return (this._webhooks ?? (this._webhooks = new Client_js_4.WebhooksClient(this._options)));
+        return (this._webhooks ?? (this._webhooks = new Client_js_3.WebhooksClient(this._options)));
     }
     /**
-     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text)
+     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids.
      *
      * @param {HydraDB.SearchQueryRequest} request
      * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/api/client/requests/SearchQueryRequest.d.ts

@@ -6,34 +6,45 @@ import type * as HydraDB from "../../index.js";
 export interface SearchQueryRequest {
     additionalContext?: string;
     alpha?: unknown;
+    collection?: string;
+    /** Preferred /query scope selector. Send either a list of collection IDs for equal normalized weighting, or an object mapping collection ID to a positive relative ranking weight with at most one decimal place. Do not send together with the deprecated sub_tenant_ids or sub_tenant_id. */
+    collections?: HydraDB.SearchQueryRequestCollections;
     /**
-     * GraphContextPtr shadows the embedded RecallSearchRequest.GraphContext bool
-     * so JSON-omitted maps to default-true; resolveGraphContext writes through.
+     * Database is the canonical v2 name for the tenant scope. TenantID is its
+     * deprecated alias and remains fully accepted. The TenantAliases middleware
+     * reconciles the two before binding, so TenantID is always populated and the
+     * handler reads it; Database/Collection are carried only for docs/OpenAPI.
      */
+    database?: string;
+    /** Whether to include graph context in the response. Defaults to true for /query when omitted. */
     graphContext?: boolean;
+    /**
+     * IDs optionally scopes retrieval to specific source ids. The v2 wire field is
+     * `ids` (matching /context/list); empty means search the whole corpus. Applied
+     * as a Milvus `source_id in [...]` pre-filter that is preserved across the
+     * metadata zero-result retry, so a source-scoped search that matches nothing
+     * returns nothing rather than silently widening to the whole corpus.
+     */
+    ids?: string[];
     maxResults?: number;
-    metadataFilters?: Record<string, unknown>;
+    metadataFilters?: HydraDB.SearchMetadataFilters;
     mode?: HydraDB.SearchRecallMode;
     numRelatedChunks?: number;
     operator?: HydraDB.SearchOperator;
     query?: string;
-    /**
-     * QueryApps mirrors the v2 wire field and is forwarded into the derived
-     * RecallSearchRequest only for knowledge hybrid searches.
-     */
+    /** Whether to include app-aware knowledge retrieval. Applies to knowledge hybrid queries. */
     queryApps?: boolean;
+    /** Retrieval method to use for the query. */
     queryBy?: HydraDB.SearchQueryBy;
-    /**
-     * QueryForcefulRelationsPtr is the v2 wire field `query_forceful_relations`
-     * (Python QueryRequest exposes this and drops the v1 `search_forceful_relations`
-     * alias). resolveForcefulRelations writes it through to the embedded
-     * RecallSearchRequest.SearchForcefulRelations, defaulting to true when omitted.
-     */
+    /** Whether to force relation expansion for graph-aware query retrieval. Defaults to true when omitted. */
     queryForcefulRelations?: boolean;
     recencyBias?: number;
-    searchForcefulRelations?: boolean;
-    source?: HydraDB.SearchSourceType;
+    /** Deprecated for /query (since 2.0.1). Use collection for a single scope or collections for multiple. Backwards-compatible and will be removed in a future version. Do not send together with a multi-scope selector. */
     subTenantId?: string;
+    /** Deprecated for /query (since 2.0.1). Use collections instead; it accepts the same list or weighted-object shape. Backwards-compatible and will be removed in a future version. Do not send together with collections. */
+    subTenantIds?: HydraDB.SearchQueryRequestSubTenantIds;
+    /** deprecated: use database */
     tenantId?: string;
+    /** Corpus to query: knowledge, memory, or all. */
     type?: HydraDB.SearchSourceType;
 }

package/dist/api/errors/index.d.ts

@@ -3,5 +3,4 @@ export * from "./ConflictError.js";
 export * from "./ForbiddenError.js";
 export * from "./InternalServerError.js";
 export * from "./NotFoundError.js";
-export * from "./TooManyRequestsError.js";
 export * from "./UnprocessableEntityError.js";

package/dist/api/errors/index.js

@@ -19,5 +19,4 @@ __exportStar(require("./ConflictError.js"), exports);
 __exportStar(require("./ForbiddenError.js"), exports);
 __exportStar(require("./InternalServerError.js"), exports);
 __exportStar(require("./NotFoundError.js"), exports);
-__exportStar(require("./TooManyRequestsError.js"), exports);
 __exportStar(require("./UnprocessableEntityError.js"), exports);

package/dist/api/resources/context/client/Client.d.ts

@@ -21,7 +21,7 @@ export declare class ContextClient {
      * @example
      *     await client.context.delete()
      */
-    delete(request?: HydraDB.SourcesV2SourceDeleteRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSourcesSourceDeleteResponse>;
+    delete(request?: HydraDB.SourcesV2SourceDeleteRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSourcesMemoryDeleteResponse>;
     private __delete;
     /**
      * Ingest knowledge documents or memories for a tenant.
@@ -87,6 +87,23 @@ export declare class ContextClient {
      */
     relations(request: HydraDB.RelationsContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeGraphGraphRelationsResponse>;
     private __relations;
+    /**
+     * Merge/upsert tenant_metadata and additional_metadata for one source. sub_tenant_id is required.
+     *
+     * @param {HydraDB.HandlerContextMetadataUpdateRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.context.updateSourceMetadata({
+     *         sourceId: "HydraDoc1234"
+     *     })
+     */
+    updateSourceMetadata(request: HydraDB.HandlerContextMetadataUpdateRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeGithubComHydradbHydradbApplicationInternalServiceMetadataEditResult>;
+    private __updateSourceMetadata;
     /**
      * Return the processing status for one or more source IDs.
      *

package/dist/api/resources/context/client/Client.js

@@ -85,7 +85,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.HandlerEnvelopeSourcesSourceDeleteResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeSourcesMemoryDeleteResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -455,6 +455,95 @@ class ContextClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/relations");
     }
+    /**
+     * Merge/upsert tenant_metadata and additional_metadata for one source. sub_tenant_id is required.
+     *
+     * @param {HydraDB.HandlerContextMetadataUpdateRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.context.updateSourceMetadata({
+     *         sourceId: "HydraDoc1234"
+     *     })
+     */
+    updateSourceMetadata(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__updateSourceMetadata(request, requestOptions));
+    }
+    async __updateSourceMetadata(request, requestOptions) {
+        const { sourceId, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.HydraDBEnvironment.Default, `context/sources/${core.url.encodePathParam(sourceId)}/metadata`),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.HandlerContextMetadataUpdateRequest.jsonOrThrow(_body, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.HandlerEnvelopeGithubComHydradbHydradbApplicationInternalServiceMetadataEditResult.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
+                case 404:
+                    throw new HydraDB.NotFoundError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
+                case 500:
+                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
+                default:
+                    throw new errors.HydraDBError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "PATCH", "/context/sources/{source_id}/metadata");
+    }
     /**
      * Return the processing status for one or more source IDs.
      *

package/dist/api/resources/context/client/requests/HandlerContextMetadataUpdateRequest.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @example
+ *     {
+ *         sourceId: "HydraDoc1234"
+ *     }
+ */
+export interface HandlerContextMetadataUpdateRequest {
+    /** Source ID */
+    sourceId: string;
+    additionalMetadata?: Record<string, unknown>;
+    documentMetadata?: Record<string, unknown>;
+    subTenantId?: string;
+    tenantId?: string;
+    tenantMetadata?: Record<string, unknown>;
+}

package/dist/api/resources/context/client/requests/ListV2ListContentRequest.d.ts

@@ -4,12 +4,21 @@ import type * as HydraDB from "../../../../index.js";
  *     {}
  */
 export interface ListV2ListContentRequest {
+    collection?: string;
+    /**
+     * Database/Collection are the canonical v2 names; TenantID/SubTenantID are
+     * their deprecated aliases (reconciled here in UnmarshalJSON and centrally by
+     * the TenantAliases middleware).
+     */
+    database?: string;
     filters?: HydraDB.ListContentFilter;
     ids?: string[];
     includeFields?: string[];
     page?: number;
     pageSize?: number;
+    /** deprecated: use collection */
     subTenantId?: string;
+    /** deprecated: use database */
     tenantId?: string;
     type?: string;
 }

package/dist/api/resources/context/client/requests/SourcesV2SourceDeleteRequest.d.ts

@@ -3,8 +3,17 @@
  *     {}
  */
 export interface SourcesV2SourceDeleteRequest {
+    collection?: string;
+    /**
+     * Database/Collection are the canonical v2 names; TenantID/SubTenantID are
+     * their deprecated aliases, reconciled by the TenantAliases middleware before
+     * binding so TenantID is always populated.
+     */
+    database?: string;
     ids?: string[];
+    /** deprecated: use collection */
     subTenantId?: string;
+    /** deprecated: use database */
     tenantId?: string;
     type?: string;
 }

package/dist/api/resources/context/client/requests/index.d.ts

@@ -1,3 +1,4 @@
+export type { HandlerContextMetadataUpdateRequest } from "./HandlerContextMetadataUpdateRequest.js";
 export type { IngestContextRequest } from "./IngestContextRequest.js";
 export type { InspectContextRequest } from "./InspectContextRequest.js";
 export type { ListV2ListContentRequest } from "./ListV2ListContentRequest.js";

package/dist/api/resources/databases/client/Client.d.ts

@@ -0,0 +1,109 @@
+import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js";
+import { type NormalizedClientOptionsWithAuth } from "../../../../BaseClient.js";
+import * as core from "../../../../core/index.js";
+import * as HydraDB from "../../../index.js";
+export declare namespace DatabasesClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+export declare class DatabasesClient {
+    protected readonly _options: NormalizedClientOptionsWithAuth<DatabasesClient.Options>;
+    constructor(options: DatabasesClient.Options);
+    /**
+     * List all databases for the authenticated user
+     *
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.databases.list()
+     */
+    list(requestOptions?: DatabasesClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeTenantsTenantIdsResponse>;
+    private __list;
+    /**
+     * Create a new database with optional custom metadata schema
+     *
+     * @param {HydraDB.TenantsTenantCreateRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.ForbiddenError}
+     * @throws {@link HydraDB.ConflictError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.databases.create()
+     */
+    create(request?: HydraDB.TenantsTenantCreateRequest, requestOptions?: DatabasesClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeTenantsTenantCreateAcceptedResponse>;
+    private __create;
+    /**
+     * Delete a database and all associated data
+     *
+     * @param {HydraDB.DeleteDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.databases.delete({
+     *         database: "database"
+     *     })
+     */
+    delete(request: HydraDB.DeleteDatabasesRequest, requestOptions?: DatabasesClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeTenantsTenantDeleteResponse>;
+    private __delete;
+    /**
+     * List all collections for a given database
+     *
+     * @param {HydraDB.CollectionsDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.databases.collections({
+     *         database: "database"
+     *     })
+     */
+    collections(request: HydraDB.CollectionsDatabasesRequest, requestOptions?: DatabasesClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeTenantsSubTenantIdsResponse>;
+    private __collections;
+    /**
+     * Get collection statistics for a database
+     *
+     * @param {HydraDB.StatsDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.databases.stats({
+     *         database: "database"
+     *     })
+     */
+    stats(request: HydraDB.StatsDatabasesRequest, requestOptions?: DatabasesClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeTenantsTenantStatsResponse>;
+    private __stats;
+    /**
+     * Check the infrastructure provisioning status for a database
+     *
+     * @param {HydraDB.StatusDatabasesRequest} request
+     * @param {DatabasesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.databases.status({
+     *         database: "database"
+     *     })
+     */
+    status(request: HydraDB.StatusDatabasesRequest, requestOptions?: DatabasesClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeTenantsInfraStatusResponseV2>;
+    private __status;
+}