@hydradb/sdk 2.1.4 → 2.1.6

package/dist/api/resources/connectors/client/requests/PauseConnectorsRequest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234"
+ *     }
+ */
+export interface PauseConnectorsRequest {
+    /** Connector ID */
+    id: string;
+}

package/dist/api/resources/connectors/client/requests/ResumeConnectorsRequest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234"
+ *     }
+ */
+export interface ResumeConnectorsRequest {
+    /** Connector ID */
+    id: string;
+}

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

@@ -7,9 +7,13 @@ export type { HandlerConnectorCreateReq } from "./HandlerConnectorCreateReq.js";
 export type { HandlerConnectorUpdateReq } from "./HandlerConnectorUpdateReq.js";
 export type { HandlerDiscoverPreviewReq } from "./HandlerDiscoverPreviewReq.js";
 export type { HandlerResourceCreateReq } from "./HandlerResourceCreateReq.js";
+export type { HandlerVaultCredentialRevealReq } from "./HandlerVaultCredentialRevealReq.js";
+export type { HandlerVaultCredentialUpdateReq } from "./HandlerVaultCredentialUpdateReq.js";
 export type { ListConnectorsRequest } from "./ListConnectorsRequest.js";
 export type { ListResourcesConnectorsRequest } from "./ListResourcesConnectorsRequest.js";
 export type { PatchConnectorsIdCredentialsRequest } from "./PatchConnectorsIdCredentialsRequest.js";
+export type { PauseConnectorsRequest } from "./PauseConnectorsRequest.js";
+export type { ResumeConnectorsRequest } from "./ResumeConnectorsRequest.js";
 export type { StatusConnectorsRequest } from "./StatusConnectorsRequest.js";
 export type { SyncConnectorsRequest } from "./SyncConnectorsRequest.js";
 export type { UpdateResourceAclConnectorsRequest } from "./UpdateResourceAclConnectorsRequest.js";

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. `context` is the preferred shape (text or a conversation per item); the deprecated `documents`, `app_knowledge` and `memories` fields are selected by `type`. The same `context` 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: knowledge sources (default) or memories, selected by `type`.
      *
      * @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.
      *
@@ -132,7 +172,7 @@ export declare class ContextClient {
     status(request: HydraDB.StatusContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeIngestionV2BatchProcessingStatus>;
     private __status;
     /**
-     * Return the connected subgraph of a source: every source reachable from it through source-level relations (RELATES_TO edges, shared thread, parent/child hierarchy, traversed BFS), the relations among them, and the auxiliary graph around them (entities, comments, attachments, actors). Chunk-level entity relations are not included.
+     * 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.
@@ -141,11 +181,11 @@ export declare class ContextClient {
      *
      * @example
      *     await client.context.subgraph({
+     *         id: "HydraDoc1234",
      *         database: "acme_corp",
      *         collection: "team_docs",
      *         tenantId: "tenant_1234",
-     *         subTenantId: "sub_tenant_4567",
-     *         id: "HydraDoc1234"
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
     subgraph(request: HydraDB.SubgraphContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeGraphSourceSubgraphResponse>;

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. `context` is the preferred shape (text or a conversation per item); the deprecated `documents`, `app_knowledge` and `memories` fields are selected by `type`. The same `context` array may also be sent as an application/json body.
      *
      * @param {HydraDB.IngestContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -170,16 +259,27 @@ class ContextClient {
         if (request.collection != null) {
             _body.append("collection", request.collection);
         }
+        if (request.context != null) {
+            _body.append("context", request.context);
+        }
         _body.append("database", request.database);
         if (request.documentMetadata != null) {
             _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.enrich != null) {
+            _body.append("enrich", request.enrich);
         }
         if (request.graphPayload != null) {
             _body.append("graph_payload", request.graphPayload);
         }
+        if (request.instructions != null) {
+            _body.append("instructions", request.instructions);
+        }
         if (request.memories != null) {
             _body.append("memories", request.memories);
         }
@@ -364,7 +464,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: knowledge sources (default) or memories, selected by `type`.
      *
      * @param {HydraDB.ListV2ListContentRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -431,6 +531,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.
      *
@@ -602,7 +794,7 @@ class ContextClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/status");
     }
     /**
-     * Return the connected subgraph of a source: every source reachable from it through source-level relations (RELATES_TO edges, shared thread, parent/child hierarchy, traversed BFS), the relations among them, and the auxiliary graph around them (entities, comments, attachments, actors). Chunk-level entity relations are not included.
+     * 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.
@@ -611,24 +803,24 @@ class ContextClient {
      *
      * @example
      *     await client.context.subgraph({
+     *         id: "HydraDoc1234",
      *         database: "acme_corp",
      *         collection: "team_docs",
      *         tenantId: "tenant_1234",
-     *         subTenantId: "sub_tenant_4567",
-     *         id: "HydraDoc1234"
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
     subgraph(request, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__subgraph(request, requestOptions));
     }
     async __subgraph(request, requestOptions) {
-        const { database, collection, tenantId, subTenantId, id, type: type_, depth, maxSources, acl } = request;
+        const { id, database, collection, tenantId, subTenantId, type: type_, depth, maxSources, acl } = request;
         const _queryParams = {
+            id,
             database,
             collection,
             tenant_id: tenantId,
             sub_tenant_id: subTenantId,
-            id,
             type: type_ != null
                 ? serializers.SubgraphContextRequestType.jsonOrThrow(type_, {
                     unrecognizedObjectKeys: "strip",

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[];
+    /** Deprecated: kept for split databases. Corpus type: 'knowledge' (default), 'memory', or 'all'. 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/IngestContextRequest.d.ts

@@ -7,15 +7,19 @@ 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. 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. */
+    /** 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;
+    /** JSON-encoded array of contexts -- text or a conversation per item. The same array may also be POSTed as an application/json body under `context`; that variant is not listed here so SDK generators emit this form, which carries every field. */
+    context?: 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;
+    enrich?: string;
     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. */
+    instructions?: 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/ListV2ListContentRequest.d.ts

@@ -35,6 +35,9 @@ export interface ListV2ListContentRequest {
     subTenantId?: string;
     /** deprecated: use database */
     tenantId?: string;
-    /** Bucket to list: `knowledge` (default) or `memory`. */
+    /**
+     * Deprecated: kept for split databases.
+     * Type names the corpus: knowledge (default) or memory.
+     */
     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/RelationsContextRequest.d.ts

@@ -20,7 +20,7 @@ export interface RelationsContextRequest {
     subTenantId?: string;
     /** Source ID (omit for database-wide relations) */
     id?: string;
-    /** Corpus type: 'knowledge' or 'memory' */
+    /** Deprecated: kept for split databases. Corpus type: 'knowledge' (default), 'memory', or 'all'. 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;

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`. */
+    /**
+     * Deprecated: kept for split databases.
+     * Type names the corpus: knowledge (default) or memory.
+     */
     type?: HydraDB.SourcesV2SourceDeleteRequestType;
 }

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

@@ -2,14 +2,16 @@ import type * as HydraDB from "../../../../index.js";
 /**
  * @example
  *     {
+ *         id: "HydraDoc1234",
  *         database: "acme_corp",
  *         collection: "team_docs",
  *         tenantId: "tenant_1234",
- *         subTenantId: "sub_tenant_4567",
- *         id: "HydraDoc1234"
+ *         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) */
@@ -18,14 +20,12 @@ export interface SubgraphContextRequest {
     tenantId?: string;
     /** Deprecated alias for collection */
     subTenantId?: string;
-    /** Seed source ID */
-    id: string;
-    /** Corpus type: 'knowledge' or 'memory' */
+    /** Deprecated: kept for split databases. Corpus type: 'knowledge' (default), 'memory', or 'all'. This read addresses one corpus, so 'all' answers from knowledge and meta.source_type reports which corpus answered. */
     type?: HydraDB.SubgraphContextRequestType;
-    /** Max BFS depth */
+    /** Max traversal depth in hops */
     depth?: number;
-    /** Max subgraph members */
+    /** Max members returned; `is_truncated` reports when this clipped the traversal */
     maxSources?: number;
-    /** Principals to answer as (PRO-1684 document ACLs): the subgraph contains only sources they may see, filtered at every hop. Repeated (acl=a&acl=b) or comma-separated. Omit for no ACL scoping. */
+    /** 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/index.d.ts

@@ -1,7 +1,9 @@
+export type { ChunksContextRequest } from "./ChunksContextRequest.js";
 export type { HandlerContextMetadataUpdateRequest } from "./HandlerContextMetadataUpdateRequest.js";
 export type { IngestContextRequest } from "./IngestContextRequest.js";
 export type { InspectContextRequest } from "./InspectContextRequest.js";
 export type { ListV2ListContentRequest } from "./ListV2ListContentRequest.js";
+export type { ProfileContextRequest } from "./ProfileContextRequest.js";
 export type { RelationsContextRequest } from "./RelationsContextRequest.js";
 export type { SourcesV2SourceDeleteRequest } from "./SourcesV2SourceDeleteRequest.js";
 export type { StatusContextRequest } from "./StatusContextRequest.js";

package/dist/api/resources/context/types/ChunksContextRequestType.d.ts

@@ -0,0 +1,6 @@
+export declare const ChunksContextRequestType: {
+    readonly Knowledge: "knowledge";
+    readonly Memory: "memory";
+    readonly All: "all";
+};
+export type ChunksContextRequestType = (typeof ChunksContextRequestType)[keyof typeof ChunksContextRequestType];

package/dist/api/resources/context/types/ChunksContextRequestType.js

@@ -0,0 +1,9 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunksContextRequestType = void 0;
+exports.ChunksContextRequestType = {
+    Knowledge: "knowledge",
+    Memory: "memory",
+    All: "all",
+};

package/dist/api/resources/context/types/ListV2ListContentRequestType.d.ts

@@ -1,6 +1,10 @@
-/** Bucket to list: `knowledge` (default) or `memory`. */
+/**
+ * Deprecated: kept for split databases.
+ * Type names the corpus: knowledge (default) or memory.
+ */
 export declare const ListV2ListContentRequestType: {
     readonly Knowledge: "knowledge";
     readonly Memory: "memory";
+    readonly All: "all";
 };
 export type ListV2ListContentRequestType = (typeof ListV2ListContentRequestType)[keyof typeof ListV2ListContentRequestType];

package/dist/api/resources/context/types/ListV2ListContentRequestType.js

@@ -2,8 +2,12 @@
 // This file was auto-generated by Fern from our API Definition.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListV2ListContentRequestType = void 0;
-/** Bucket to list: `knowledge` (default) or `memory`. */
+/**
+ * Deprecated: kept for split databases.
+ * Type names the corpus: knowledge (default) or memory.
+ */
 exports.ListV2ListContentRequestType = {
     Knowledge: "knowledge",
     Memory: "memory",
+    All: "all",
 };

package/dist/api/resources/context/types/ProfileContextRequestType.d.ts

@@ -0,0 +1,5 @@
+export declare const ProfileContextRequestType: {
+    readonly Knowledge: "knowledge";
+    readonly Memory: "memory";
+};
+export type ProfileContextRequestType = (typeof ProfileContextRequestType)[keyof typeof ProfileContextRequestType];

package/dist/api/resources/context/types/ProfileContextRequestType.js

@@ -0,0 +1,8 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileContextRequestType = void 0;
+exports.ProfileContextRequestType = {
+    Knowledge: "knowledge",
+    Memory: "memory",
+};

package/dist/api/resources/context/types/RelationsContextRequestType.d.ts

@@ -1,5 +1,6 @@
 export declare const RelationsContextRequestType: {
     readonly Knowledge: "knowledge";
     readonly Memory: "memory";
+    readonly All: "all";
 };
 export type RelationsContextRequestType = (typeof RelationsContextRequestType)[keyof typeof RelationsContextRequestType];