@hydradb/sdk 2.1.3 → 2.1.5

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

@@ -41,7 +41,26 @@ export declare class ContextClient {
     delete(request?: HydraDB.SourcesV2SourceDeleteRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSourcesMemoryDeleteResponse>;
     private __delete;
     /**
-     * Ingest knowledge documents or memories for a tenant.
+     * Return the indexed chunk text for a source, or for a specific set of chunk ids (the ids a graph relation cites as its evidence). Chunk rows are read from the document store first and from the vector store for anything it does not hold. Chunks whose source the request's principals may not see are omitted, and so are chunks whose source cannot be established.
+     *
+     * @param {HydraDB.ChunksContextRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     *
+     * @example
+     *     await client.context.chunks({
+     *         database: "acme_corp",
+     *         collection: "team_docs",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567",
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    chunks(request: HydraDB.ChunksContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSearchChunkInspectResult>;
+    private __chunks;
+    /**
+     * Ingest content for a database. `items` is the unified shape (text or a conversation per item) and the only one a unified database accepts; a split database still takes the deprecated `documents`, `app_knowledge` and `memories` fields selected by `type`. The same `items` array may also be sent as an application/json body.
      *
      * @param {HydraDB.IngestContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -81,7 +100,7 @@ export declare class ContextClient {
     inspect(request: HydraDB.InspectContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeFetchV2SourceFetchResponse>;
     private __inspect;
     /**
-     * List knowledge sources or memories (id + metadata) for a tenant.
+     * List items (id + metadata) for a database. Split database: knowledge sources (default) or memories, selected by `type`. Unified database: every item in one page (type=unified, the default).
      *
      * @param {HydraDB.ListV2ListContentRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -93,6 +112,27 @@ export declare class ContextClient {
      */
     list(request?: HydraDB.ListV2ListContentRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeListV2ListResponse>;
     private __list;
+    /**
+     * Return the compiled profile of one entity in one collection: identity headline, a cited summary, and the current admitted entries (each pointing at the statements behind it). Profiles are maintained continuously by the ingestion pipeline's entity keeper; this endpoint reads the materialized view and never triggers recomputation.
+     *
+     * @param {HydraDB.ProfileContextRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     *
+     * @example
+     *     await client.context.profile({
+     *         database: "acme_corp",
+     *         collection: "team_docs",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567",
+     *         subject: "subject",
+     *         namespace: "organization"
+     *     })
+     */
+    profile(request: HydraDB.ProfileContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSearchEntityProfileView>;
+    private __profile;
     /**
      * Return knowledge-graph relations for a tenant or a single source.
      *
@@ -131,6 +171,25 @@ export declare class ContextClient {
      */
     status(request: HydraDB.StatusContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeIngestionV2BatchProcessingStatus>;
     private __status;
+    /**
+     * Query-string form of GET /context/{id}/subgraph: the same parameters, the same response, and the same rules. It exists for an id that contains '/', which cannot be spelled as one path segment; generated SDKs call this form for every id. Return the connected subgraph of one ingested item: every item reachable from it through item-level relations (explicit `relates_to` links, a shared thread, parent/child hierarchy, traversed breadth-first up to `depth` hops), the relations among those members, and the structural graph around them (entities, comments, attachments, actors). Chunk-level entity relations are not included; use Inspecting Context Relations for those. An unknown id returns an empty subgraph, not an error.
+     *
+     * @param {HydraDB.SubgraphContextRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     *
+     * @example
+     *     await client.context.subgraph({
+     *         id: "HydraDoc1234",
+     *         database: "acme_corp",
+     *         collection: "team_docs",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567"
+     *     })
+     */
+    subgraph(request: HydraDB.SubgraphContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeGraphSourceSubgraphResponse>;
+    private __subgraph;
     /**
      * Merge/upsert database_metadata and additional_metadata for one source. collection is required.
      *

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

@@ -143,7 +143,96 @@ class ContextClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/context");
     }
     /**
-     * Ingest knowledge documents or memories for a tenant.
+     * Return the indexed chunk text for a source, or for a specific set of chunk ids (the ids a graph relation cites as its evidence). Chunk rows are read from the document store first and from the vector store for anything it does not hold. Chunks whose source the request's principals may not see are omitted, and so are chunks whose source cannot be established.
+     *
+     * @param {HydraDB.ChunksContextRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     *
+     * @example
+     *     await client.context.chunks({
+     *         database: "acme_corp",
+     *         collection: "team_docs",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567",
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    chunks(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__chunks(request, requestOptions));
+    }
+    async __chunks(request, requestOptions) {
+        const { database, collection, tenantId, subTenantId, id, chunkIds, type: type_, limit, acl } = request;
+        const _queryParams = {
+            database,
+            collection,
+            tenant_id: tenantId,
+            sub_tenant_id: subTenantId,
+            id,
+            chunk_ids: chunkIds,
+            type: type_ != null
+                ? serializers.ChunksContextRequestType.jsonOrThrow(type_, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
+            limit,
+            acl,
+        };
+        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/chunks"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            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.HandlerEnvelopeSearchChunkInspectResult.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);
+                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, "GET", "/context/chunks");
+    }
+    /**
+     * Ingest content for a database. `items` is the unified shape (text or a conversation per item) and the only one a unified database accepts; a split database still takes the deprecated `documents`, `app_knowledge` and `memories` fields selected by `type`. The same `items` array may also be sent as an application/json body.
      *
      * @param {HydraDB.IngestContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -175,11 +264,16 @@ class ContextClient {
             _body.append("document_metadata", request.documentMetadata);
         }
         if (request.documents != null) {
-            await _body.appendFile("documents", request.documents);
+            for (const _file of request.documents) {
+                await _body.appendFile("documents", _file);
+            }
         }
         if (request.graphPayload != null) {
             _body.append("graph_payload", request.graphPayload);
         }
+        if (request.items != null) {
+            _body.append("items", request.items);
+        }
         if (request.memories != null) {
             _body.append("memories", request.memories);
         }
@@ -299,7 +393,7 @@ class ContextClient {
         return core.HttpResponsePromise.fromPromise(this.__inspect(request, requestOptions));
     }
     async __inspect(request, requestOptions) {
-        const { id, database, collection, tenantId, subTenantId, expirySeconds, mode } = request;
+        const { id, database, collection, tenantId, subTenantId, expirySeconds, mode, acl } = request;
         const _queryParams = {
             id,
             database,
@@ -308,6 +402,7 @@ class ContextClient {
             sub_tenant_id: subTenantId,
             expiry_seconds: expirySeconds,
             mode,
+            acl,
         };
         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);
@@ -363,7 +458,7 @@ class ContextClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/inspect");
     }
     /**
-     * List knowledge sources or memories (id + metadata) for a tenant.
+     * List items (id + metadata) for a database. Split database: knowledge sources (default) or memories, selected by `type`. Unified database: every item in one page (type=unified, the default).
      *
      * @param {HydraDB.ListV2ListContentRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -430,6 +525,98 @@ class ContextClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/context/list");
     }
+    /**
+     * Return the compiled profile of one entity in one collection: identity headline, a cited summary, and the current admitted entries (each pointing at the statements behind it). Profiles are maintained continuously by the ingestion pipeline's entity keeper; this endpoint reads the materialized view and never triggers recomputation.
+     *
+     * @param {HydraDB.ProfileContextRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     *
+     * @example
+     *     await client.context.profile({
+     *         database: "acme_corp",
+     *         collection: "team_docs",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567",
+     *         subject: "subject",
+     *         namespace: "organization"
+     *     })
+     */
+    profile(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__profile(request, requestOptions));
+    }
+    async __profile(request, requestOptions) {
+        const { database, collection, tenantId, subTenantId, subject, type: type_, entityType, namespace } = request;
+        const _queryParams = {
+            database,
+            collection,
+            tenant_id: tenantId,
+            sub_tenant_id: subTenantId,
+            subject,
+            type: type_ != null
+                ? serializers.ProfileContextRequestType.jsonOrThrow(type_, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
+            entity_type: entityType,
+            namespace,
+        };
+        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/profile"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            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.HandlerEnvelopeSearchEntityProfileView.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(_response.error.body, _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, "GET", "/context/profile");
+    }
     /**
      * Return knowledge-graph relations for a tenant or a single source.
      *
@@ -451,7 +638,7 @@ class ContextClient {
         return core.HttpResponsePromise.fromPromise(this.__relations(request, requestOptions));
     }
     async __relations(request, requestOptions) {
-        const { database, collection, tenantId, subTenantId, id, type: type_, limit, cursor } = request;
+        const { database, collection, tenantId, subTenantId, id, type: type_, limit, cursor, acl } = request;
         const _queryParams = {
             database,
             collection,
@@ -466,6 +653,7 @@ class ContextClient {
                 : undefined,
             limit,
             cursor,
+            acl,
         };
         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);
@@ -599,6 +787,95 @@ class ContextClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/status");
     }
+    /**
+     * Query-string form of GET /context/{id}/subgraph: the same parameters, the same response, and the same rules. It exists for an id that contains '/', which cannot be spelled as one path segment; generated SDKs call this form for every id. Return the connected subgraph of one ingested item: every item reachable from it through item-level relations (explicit `relates_to` links, a shared thread, parent/child hierarchy, traversed breadth-first up to `depth` hops), the relations among those members, and the structural graph around them (entities, comments, attachments, actors). Chunk-level entity relations are not included; use Inspecting Context Relations for those. An unknown id returns an empty subgraph, not an error.
+     *
+     * @param {HydraDB.SubgraphContextRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     *
+     * @example
+     *     await client.context.subgraph({
+     *         id: "HydraDoc1234",
+     *         database: "acme_corp",
+     *         collection: "team_docs",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567"
+     *     })
+     */
+    subgraph(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__subgraph(request, requestOptions));
+    }
+    async __subgraph(request, requestOptions) {
+        const { id, database, collection, tenantId, subTenantId, type: type_, depth, maxSources, acl } = request;
+        const _queryParams = {
+            id,
+            database,
+            collection,
+            tenant_id: tenantId,
+            sub_tenant_id: subTenantId,
+            type: type_ != null
+                ? serializers.SubgraphContextRequestType.jsonOrThrow(type_, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
+            depth,
+            max_sources: maxSources,
+            acl,
+        };
+        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/subgraph"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            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.HandlerEnvelopeGraphSourceSubgraphResponse.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);
+                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, "GET", "/context/subgraph");
+    }
     /**
      * Merge/upsert database_metadata and additional_metadata for one source. collection is required.
      *

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

@@ -0,0 +1,31 @@
+import type * as HydraDB from "../../../../index.js";
+/**
+ * @example
+ *     {
+ *         database: "acme_corp",
+ *         collection: "team_docs",
+ *         tenantId: "tenant_1234",
+ *         subTenantId: "sub_tenant_4567",
+ *         id: "HydraDoc1234"
+ *     }
+ */
+export interface ChunksContextRequest {
+    /** Database (canonical name for the tenant scope) */
+    database: string;
+    /** Collection (canonical name for the sub-tenant scope) */
+    collection?: string;
+    /** Deprecated alias for database */
+    tenantId?: string;
+    /** Deprecated alias for collection */
+    subTenantId?: string;
+    /** Source ID whose chunks to return. Required unless chunk_ids is given. */
+    id?: string;
+    /** Chunk IDs to return. Repeated (chunk_ids=a&chunk_ids=b) or comma-separated. Takes precedence over id. */
+    chunkIds?: string | string[];
+    /** Corpus type. Split database: 'knowledge' (default), 'memory', or 'all'. Unified database: 'unified' (default); knowledge/memory are rejected. This read addresses one corpus, so 'all' answers from knowledge and meta.source_type reports which corpus answered. */
+    type?: HydraDB.ChunksContextRequestType;
+    /** Max chunks to return */
+    limit?: number;
+    /** Principals to answer as (PRO-1684 document ACLs): only chunks whose source they may see are returned. Repeated (acl=a&acl=b) or comma-separated. Omit for no ACL scoping. */
+    acl?: string | string[];
+}

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

@@ -7,6 +7,20 @@
 export interface HandlerContextMetadataUpdateRequest {
     /** Source ID */
     id: string;
+    /**
+     * ACL, when present, REPLACES the source's access-control list without
+     * re-ingestion (PRO-1684): pass the COMPLETE new allow-list (adding a
+     * third user means sending all three), an empty list to make the source
+     * private, or ["__public__"] to open it to every identified caller. A
+     * pointer so omitted (nil, ACL untouched) is distinguishable from an
+     * explicit empty list (private).
+     * ACL uses RawMessage so the handler can tell three wire states apart:
+     * absent (leave the stored ACL untouched), explicit null (revoke to
+     * nobody, JSON-merge-patch semantics), and a list (replace). A plain
+     * *[]string cannot: encoding/json leaves the pointer nil for BOTH
+     * absent and null, which silently ignored an explicit null revocation.
+     */
+    acl?: string[];
     /** Free-form key-value pairs to merge into the source's `additional_metadata`. The only accepted spelling for document metadata on this endpoint. Capped at 1 KiB, measured on the compact JSON encoding of the whole map in UTF-8 bytes — keys, quotes, commas and braces count toward the budget. Over-cap returns 400 with the actual byte count. */
     additionalMetadata?: Record<string, unknown>;
     /** Collection scope. Defaults to the default collection when omitted. Formerly `sub_tenant_id`; the `sub_tenant_id` alias is still accepted (deprecated). */

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

@@ -7,15 +7,17 @@ import type * as HydraDB from "../../../../index.js";
  *     }
  */
 export interface IngestContextRequest {
-    /** App-knowledge items as a JSON array (type=knowledge). Per item, `metadata` is capped at 16 KiB and `additional_metadata` at 1 KiB, measured on the compact JSON encoding of the whole map in UTF-8 bytes (keys and punctuation count). The deprecated `tenant_metadata` / `document_metadata` spellings are accepted here and held to the same caps. Over-cap returns 400 with the actual byte count. */
+    /** App-knowledge items as a JSON array (type=knowledge). Per item, `metadata` is capped at 16 KiB and `additional_metadata` at 1 KiB, measured on the compact JSON encoding of the whole map in UTF-8 bytes (keys and punctuation count). The deprecated `tenant_metadata` / `document_metadata` spellings are accepted here and held to the same caps. Over-cap returns 400 with the actual byte count. Each item may also carry `acl`, a list of principals (`user_email:<email>`, a bare email, `group:<provider>:<id>`, `domain:<domain>`, or `__public__`) restricting who may retrieve it; omit it to leave the document unrestricted, and send an empty list to restrict it to nobody. A malformed principal rejects the whole request with 400. Items may also carry `evidence_kind`/`evidence_subject` provenance labels (see document_metadata); an unknown kind returns 400. */
     appKnowledge?: string;
     collection?: string;
     database: string;
-    /** Per-document metadata as a JSON array (type=knowledge). Per item, `metadata` is capped at 16 KiB and `additional_metadata` at 1 KiB. Both caps are measured on the compact JSON encoding of the whole map in UTF-8 bytes, so keys, quotes, commas and braces count toward the budget. Over-cap returns 400 with the actual byte count. */
+    /** Per-document metadata as a JSON array (type=knowledge). Per item, `metadata` is capped at 16 KiB and `additional_metadata` at 1 KiB. Both caps are measured on the compact JSON encoding of the whole map in UTF-8 bytes, so keys, quotes, commas and braces count toward the budget. Over-cap returns 400 with the actual byte count. Each item may also carry evidence labels (`evidence_kind`: one of assertion, record, said, done, third_party, inferred; `evidence_subject`: a stable handle for who the evidence is about, e.g. `user:kiran@acme.com`) declaring the content's provenance for entity understanding; an unknown kind returns 400. */
     documentMetadata?: string;
-    documents?: core.file.Uploadable | undefined;
+    documents?: core.file.Uploadable[] | undefined;
     graphPayload?: string;
-    /** Memory items as a JSON array (type=memory). Per item, `metadata` is capped at 16 KiB and `additional_metadata` at 1 KiB, measured on the compact JSON encoding of the whole map in UTF-8 bytes (keys and punctuation count). Over-cap returns 400 with the actual byte count. */
+    /** JSON-encoded array of ingest items -- the unified shape (text or a conversation per item), and the only one a unified database accepts. The same array may also be POSTed as an application/json body; that variant is not listed here so SDK generators emit this form, which carries every field. */
+    items?: string;
+    /** Memory items as a JSON array (type=memory). Per item, `metadata` is capped at 16 KiB and `additional_metadata` at 1 KiB, measured on the compact JSON encoding of the whole map in UTF-8 bytes (keys and punctuation count). Over-cap returns 400 with the actual byte count. Items may also carry `evidence_kind`/`evidence_subject` provenance labels (see document_metadata); an unknown kind returns 400. */
     memories?: string;
     subTenantId?: string;
     tenantId?: string;

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

@@ -24,4 +24,6 @@ export interface InspectContextRequest {
     expirySeconds?: number;
     /** Fetch mode */
     mode?: string;
+    /** Principals to answer as (PRO-1684 document ACLs): the source must be visible to them, or the response is 404. Repeated (acl=a&acl=b) or comma-separated. Omit for no ACL scoping. */
+    acl?: string | string[];
 }

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

@@ -4,6 +4,8 @@ import type * as HydraDB from "../../../../index.js";
  *     {}
  */
 export interface ListV2ListContentRequest {
+    /** ACL: see ListContentRequest.ACL (PRO-1684 document ACLs). */
+    acl?: string[];
     /** Collection scope. Defaults to the default collection when omitted. Formerly `sub_tenant_id`; the `sub_tenant_id` alias is still accepted (deprecated). */
     collection?: string;
     /**
@@ -33,6 +35,10 @@ export interface ListV2ListContentRequest {
     subTenantId?: string;
     /** deprecated: use database */
     tenantId?: string;
-    /** Bucket to list: `knowledge` (default) or `memory`. */
+    /**
+     * Type names the corpus. Split database: knowledge (default) or memory.
+     * Unified database: unified (default), every item in one page;
+     * knowledge/memory are rejected there.
+     */
     type?: HydraDB.ListV2ListContentRequestType;
 }

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

@@ -0,0 +1,30 @@
+import type * as HydraDB from "../../../../index.js";
+/**
+ * @example
+ *     {
+ *         database: "acme_corp",
+ *         collection: "team_docs",
+ *         tenantId: "tenant_1234",
+ *         subTenantId: "sub_tenant_4567",
+ *         subject: "subject",
+ *         namespace: "organization"
+ *     }
+ */
+export interface ProfileContextRequest {
+    /** Database (canonical name for the tenant scope) */
+    database: string;
+    /** Collection (canonical name for the sub-tenant scope) */
+    collection: string;
+    /** Deprecated alias for database */
+    tenantId?: string;
+    /** Deprecated alias for collection */
+    subTenantId?: string;
+    /** Entity whose profile to return (e.g. a person's name) */
+    subject: string;
+    /** Corpus type: 'knowledge' or 'memory' */
+    type?: HydraDB.ProfileContextRequestType;
+    /** Graph entity type of the subject */
+    entityType?: string;
+    /** Graph namespace of the subject */
+    namespace?: string;
+}

package/dist/api/resources/context/client/requests/ProfileContextRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -20,10 +20,12 @@ export interface RelationsContextRequest {
     subTenantId?: string;
     /** Source ID (omit for database-wide relations) */
     id?: string;
-    /** Corpus type: 'knowledge' or 'memory' */
+    /** Corpus type. Split database: 'knowledge' (default), 'memory', or 'all'. Unified database: 'unified' (default); knowledge/memory are rejected. This read addresses one corpus, so 'all' answers from knowledge and meta.source_type reports which corpus answered. */
     type?: HydraDB.RelationsContextRequestType;
     /** Max relations to return */
     limit?: number;
     /** Pagination cursor */
     cursor?: number;
+    /** Principals to answer as (PRO-1684 document ACLs): only relations attributable to sources they may see are returned. Repeated (acl=a&acl=b) or comma-separated. Omit for no ACL scoping. */
+    acl?: string | string[];
 }

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

@@ -20,6 +20,9 @@ export interface SourcesV2SourceDeleteRequest {
     subTenantId?: string;
     /** deprecated: use database */
     tenantId?: string;
-    /** Bucket to delete from: `knowledge` (default) or `memory`. */
+    /**
+     * Type names the corpus. Split database: knowledge (default) or memory.
+     * Unified database: unified (default); knowledge/memory are rejected there.
+     */
     type?: HydraDB.SourcesV2SourceDeleteRequestType;
 }

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

@@ -0,0 +1,31 @@
+import type * as HydraDB from "../../../../index.js";
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234",
+ *         database: "acme_corp",
+ *         collection: "team_docs",
+ *         tenantId: "tenant_1234",
+ *         subTenantId: "sub_tenant_4567"
+ *     }
+ */
+export interface SubgraphContextRequest {
+    /** Item ID: the ingested item whose connected subgraph to return. This form takes any id, including one that contains '/'. */
+    id: string;
+    /** Database (canonical name for the tenant scope) */
+    database: string;
+    /** Collection (canonical name for the sub-tenant scope) */
+    collection?: string;
+    /** Deprecated alias for database */
+    tenantId?: string;
+    /** Deprecated alias for collection */
+    subTenantId?: string;
+    /** Corpus type. Split database: 'knowledge' (default), 'memory', or 'all'. Unified database: 'unified' (default); knowledge/memory are rejected. This read addresses one corpus, so 'all' answers from knowledge and meta.source_type reports which corpus answered. */
+    type?: HydraDB.SubgraphContextRequestType;
+    /** Max traversal depth in hops */
+    depth?: number;
+    /** Max members returned; `is_truncated` reports when this clipped the traversal */
+    maxSources?: number;
+    /** Principals to answer as (document ACLs): the subgraph contains only items they may see, filtered at every hop. Repeated (acl=a&acl=b) or comma-separated. Omit for no ACL scoping. */
+    acl?: string | string[];
+}

package/dist/api/resources/context/client/requests/SubgraphContextRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });