@kortexya/reasoninglayer 7.2.0 → 8.1.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "7.2.0";
+var SDK_VERSION = "8.1.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -16968,6 +16968,23 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name LookupRecords
+   * @summary `GET /api/v1/vocabulary/records` — the records of one view with the ids asked (#632). A client names the few records a finding, a conflict or a list cites without reading a whole release or change set; the view is the cached release or candidate view, so a lookup costs the ids asked.
+   * @request GET:/api/v1/vocabulary/records
+   * @secure
+   */
+  lookupRecords = (query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/records`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -17106,6 +17123,23 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name RevisionRecords
+   * @summary `GET /api/v1/vocabulary/revisions/{revision_id}/records` — the records the revision's cumulative change set inserts or replaces, by id, optionally of one kind (#628). The revision answer counts them; this read pages them from the cached candidate view, so a page costs a page once the revision is indexed (#630).
+   * @request GET:/api/v1/vocabulary/revisions/{revision_id}/records
+   * @secure
+   */
+  revisionRecords = (revisionId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/revisions/${revisionId}/records`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -19573,7 +19607,8 @@ var RESPONSE_COMPONENTS = {
       created_by: [1, 0],
       minted_ids: [1, { object: {} }],
       outcome: [1, 0],
-      records: [1, { array: 0 }],
+      proposal_counts: [1, { object: {} }],
+      record_counts: [1, { object: {} }],
       removals: [1, { array: 0 }],
       replayed: [1, 0],
       revision_id: [1, 0],
@@ -25336,6 +25371,14 @@ var RESPONSE_COMPONENTS = {
   },
   RecordEpisodeResponse: { object: { episode_id: [1, 0], message: [1, 0] } },
   RecordFeatureChangeDto: { object: { feature: [1, 0] } },
+  RecordLookupResponse: {
+    object: {
+      context: [2, "ContextRefDto"],
+      items: [1, { array: 0 }],
+      missing: [1, { array: 0 }],
+      view: [1, "ViewRefDto"]
+    }
+  },
   RecordPageResponse: { object: { items: [1, { array: 0 }], release_id: [1, 0] } },
   RecordSafeHarborStatus: {
     object: {
@@ -25718,6 +25761,7 @@ var RESPONSE_COMPONENTS = {
       revision_id: [1, 0]
     }
   },
+  RevisionRecordPageResponse: { object: { items: [1, { array: 0 }], revision_id: [1, 0] } },
   RevisionSummaryDto: {
     object: {
       authors: [1, { array: 0 }],
@@ -30562,6 +30606,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/workflows",
     responses: { 200: "WorkflowListResponse" }
   },
+  lookupRecords: {
+    method: "GET",
+    path: "/api/v1/vocabulary/records",
+    responses: { 200: "RecordLookupResponse" }
+  },
   markChoicePoint: {
     method: "POST",
     path: "/api/v1/execution/sessions/{session_id}/mark",
@@ -31289,6 +31338,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/vocabulary/revisions/{revision_id}/diff",
     responses: { 200: "RevisionDiffDto" }
   },
+  revisionRecords: {
+    method: "GET",
+    path: "/api/v1/vocabulary/revisions/{revision_id}/records",
+    responses: { 200: "RevisionRecordPageResponse" }
+  },
   revokeApproverRoleHandler: {
     method: "DELETE",
     path: "/api/v1/action-reviews/role-bindings/{principal}",
@@ -39284,14 +39338,16 @@ var NamespacesClient = class {
    *
    * @param namespaceId - Namespace UUID.
    * @param requestOptions - Per-call options (timeout, retries, signal, headers).
-   * @returns The counters of this engine process since `countedSince`.
+   * @returns The engine's durable counters for the namespace since `countedSince`.
    * @throws {ForbiddenError} 403 without a native `manage_answer_cache` grant.
    * @throws {NotFoundError} 404 for a namespace not in this tenant.
-   * @throws {ServiceUnavailableError} 503 when the namespace state or authority is unavailable.
+   * @throws {ServiceUnavailableError} 503 when the namespace state, authority or savings storage is unavailable.
    *
    * @remarks
    * `GET /api/v1/namespaces/{id}/answer-cache-savings`. The counters are
-   * process-local and not durable; token savings are not measured
+   * durable and summed across engine processes and restarts; another
+   * process's counts arrive within its five-second write interval. Token
+   * savings are not measured
    * (`tokenUsageMeasured: false`). Response mapped from snake_case.
    *
    * @example
@@ -70659,6 +70715,12 @@ function TaxonomyPolicyInputFromFrontToApi(record) {
   }
   return out;
 }
+function DefinitionPolicyInputFromFrontToApi(record) {
+  return {
+    scheme: VocabularyRecordRefFromFrontToApi(record.scheme),
+    definitions: record.definitions
+  };
+}
 function ExternalConceptInputFromFrontToApi(record) {
   const out = {
     authority: record.authority,
@@ -70817,10 +70879,19 @@ function VocabularyRecordInputFromFrontToApi(record) {
       };
     case "collection_member":
       return { kind: "collection_member", ...CollectionMemberInputFromFrontToApi(record) };
+    case "definition_policy":
+      return { kind: "definition_policy", ...DefinitionPolicyInputFromFrontToApi(record) };
   }
 }
 function VocabularyRecordOperationFromFrontToApi(operation) {
-  return operation.op === "upsert" ? { op: "upsert", record: VocabularyRecordInputFromFrontToApi(operation.record) } : { op: "remove", record_id: operation.recordId };
+  switch (operation.op) {
+    case "upsert":
+      return { op: "upsert", record: VocabularyRecordInputFromFrontToApi(operation.record) };
+    case "remove":
+      return { op: "remove", record_id: operation.recordId };
+    case "accept_proposals":
+      return { op: "accept_proposals" };
+  }
 }
 function CreateVocabularyCandidateRequestFromFrontToApi(request) {
   return {
@@ -71182,6 +71253,16 @@ function VocabularyTaxonomyPolicyRecordFromApiToFront(dto) {
   if (present(dto.partitive_transitive)) out.partitiveTransitive = dto.partitive_transitive;
   return out;
 }
+function VocabularyDefinitionPolicyRecordFromApiToFront(dto) {
+  return {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    scheme: dto.scheme,
+    policy: dto.policy,
+    definitions: dto.definitions
+  };
+}
 function VocabularyExternalConceptRecordFromApiToFront(dto) {
   const out = {
     recordId: dto.record_id,
@@ -71400,6 +71481,11 @@ function VocabularyRecordViewFromApiToFront(dto) {
         kind: "migration_decision",
         ...VocabularyMigrationDecisionRecordFromApiToFront(dto)
       };
+    case "definition_policy":
+      return {
+        kind: "definition_policy",
+        ...VocabularyDefinitionPolicyRecordFromApiToFront(dto)
+      };
   }
 }
 function FindingContextFromApiToFront(dto) {
@@ -71767,7 +71853,8 @@ function VocabularyCandidateRevisionFromApiToFront(dto) {
     createdBy: dto.created_by,
     createdAt: dto.created_at,
     changeReason: dto.change_reason,
-    records: dto.records.map(VocabularyRecordViewFromApiToFront),
+    recordCounts: dataMap(dto.record_counts),
+    proposalCounts: dataMap(dto.proposal_counts),
     removals: dto.removals,
     mintedIds: dataMap(dto.minted_ids),
     advisoryFindings: dto.advisory_findings.map(VocabularyFindingFromApiToFront),
@@ -71948,6 +72035,23 @@ function VocabularyRecordPageFromApiToFront(dto) {
   if (present(dto.next_cursor)) out.nextCursor = dto.next_cursor;
   return out;
 }
+function VocabularyRevisionRecordPageFromApiToFront(dto) {
+  const out = {
+    revisionId: dto.revision_id,
+    items: dto.items.map(VocabularyRecordViewFromApiToFront)
+  };
+  if (present(dto.next_cursor)) out.nextCursor = dto.next_cursor;
+  return out;
+}
+function VocabularyRecordLookupFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    items: dto.items.map(VocabularyRecordViewFromApiToFront),
+    missing: dto.missing
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  return out;
+}
 function VocabularyActivationResultFromApiToFront(dto) {
   const out = {
     releaseId: dto.release_id,
@@ -73074,7 +73178,7 @@ var VocabularyClient = class {
     return decodeResponse(response, VocabularyCandidateRevisionFromApiToFront);
   }
   /**
-   * One revision: its baseline, authors, records and removals.
+   * One revision: its baseline, authors, record counts and removals.
    *
    * @param revisionId - The revision (UUID).
    * @param requestOptions - Per-call options (timeout, retries, signal, headers).
@@ -73083,18 +73187,84 @@ var VocabularyClient = class {
    * @throws {@link VocabularyRefusedError} 409 `vocabulary_plugin_unavailable`.
    *
    * @remarks
-   * `GET /api/v1/vocabulary/revisions/{revision_id}`.
+   * `GET /api/v1/vocabulary/revisions/{revision_id}`. The answer counts the
+   * records by kind (`recordCounts`) and the proposals among them
+   * (`proposalCounts`); read the records with
+   * {@link VocabularyClient.listRevisionRecords} or
+   * {@link VocabularyClient.lookupRecords}.
    *
    * @example
    * ```typescript
    * const revision = await client.vocabulary.getRevision(revisionId);
-   * const concepts = revision.records.filter((r) => r.kind === 'concept');
+   * const conceptCount = revision.recordCounts['concept'] ?? 0;
+   * const toAccept = Object.values(revision.proposalCounts).reduce((n, c) => n + c, 0);
    * ```
    */
   async getRevision(revisionId, requestOptions) {
     const response = await this.api.getRevision(revisionId, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
     return decodeResponse(response, VocabularyCandidateRevisionFromApiToFront);
   }
+  /**
+   * One page of the records a revision's cumulative change set inserts or
+   * replaces.
+   *
+   * @param revisionId - The revision (UUID).
+   * @param query - A record-kind filter and cursor paging (`limit` 1 to 500).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The records and the next cursor.
+   * @throws {@link NotFoundError} 404 for an unknown revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/revisions/{revision_id}/records?kind&cursor&limit`.
+   * Records come by id; the engine default page size is 50.
+   *
+   * @example
+   * ```typescript
+   * const page = await client.vocabulary.listRevisionRecords(revisionId, { kind: 'concept' });
+   * ```
+   */
+  async listRevisionRecords(revisionId, query, requestOptions) {
+    const wire = pageQuery(query);
+    if (query?.kind !== void 0) wire.kind = query.kind;
+    const response = await this.api.revisionRecords(revisionId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyRevisionRecordPageFromApiToFront);
+  }
+  /**
+   * The records of one view with the ids asked: what a client needs to name
+   * or open the few records a finding, a rebase conflict or a list cites,
+   * without reading a whole release or change set.
+   *
+   * @param ids - The record ids (UUIDs): 1 to 500 distinct ids.
+   * @param query - The view.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The records the view holds, in the order asked and each once,
+   *   and the ids it does not hold.
+   * @throws {@link NotFoundError} 404 for an unknown release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request` (an id that is
+   *   not a UUID, no id, or more than 500); 409 `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/records?ids&view&release_id&revision_id`. An id
+   * the candidate removes is `missing` in its candidate view. Duplicate ids
+   * are answered once.
+   *
+   * @example
+   * ```typescript
+   * const { items, missing } = await client.vocabulary.lookupRecords(finding.subjects, {
+   *   view: { view: 'candidate', revisionId },
+   * });
+   * ```
+   */
+  async lookupRecords(ids, query, requestOptions) {
+    const wire = {
+      ...viewQuery(query?.view),
+      ids: ids.join(",")
+    };
+    const response = await this.api.lookupRecords(wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyRecordLookupFromApiToFront);
+  }
   /**
    * A revision against its baseline: records added, changed (with per-feature
    * before/after values) and removed.