@atlanai/sdk 0.1.1 → 0.2.2

package/dist/raw/skill/apis/SkillApi.d.ts

@@ -24,16 +24,19 @@ import { type TraceDetailView } from '../models/TraceDetailView';
 import { type TraceListEnvelope } from '../models/TraceListEnvelope';
 export interface SkillAggregateRequest {
     skillSkillAggregateRequest: SkillSkillAggregateRequest;
+    contentEncoding?: SkillAggregateContentEncodingEnum;
 }
 export interface SkillArchiveRequest {
     skillId: string;
 }
 export interface SkillBulkCreateRequest {
     items: string;
+    contentEncoding?: SkillBulkCreateContentEncodingEnum;
 }
 export interface SkillCreateRequest {
     body: Blob;
     metadata: string;
+    contentEncoding?: SkillCreateContentEncodingEnum;
 }
 export interface SkillGetBundleRequest {
     skillId: string;
@@ -59,6 +62,7 @@ export interface SkillListRequest {
     offset?: number;
     license?: string;
     skillVersion?: string;
+    workspaceId?: string;
     sort?: string;
 }
 export interface SkillListInsightsRequest {
@@ -86,14 +90,17 @@ export interface SkillListSkillTracesRequest {
 export interface SkillPatchRequest {
     skillId: string;
     skillSkillPatch: SkillSkillPatch;
+    contentEncoding?: SkillPatchContentEncodingEnum;
 }
 export interface SkillQuerySkillTraceStatsRequest {
     skillId: string;
     gatewayTraceStatsRequest: GatewayTraceStatsRequest;
     versionOrdinal?: number;
+    contentEncoding?: SkillQuerySkillTraceStatsContentEncodingEnum;
 }
 export interface SkillSearchRequest {
     skillSkillSearchRequest: SkillSkillSearchRequest;
+    contentEncoding?: SkillSearchContentEncodingEnum;
 }
 /**
  *
@@ -132,12 +139,12 @@ export declare class SkillApi extends runtime.BaseAPI {
      */
     skillBulkCreateRequestOpts(requestParameters: SkillBulkCreateRequest): Promise<runtime.RequestOpts>;
     /**
-     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose `name` already names a skill in that workspace appends a version to it. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
+     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose identity (`source_id` when sent, else `name`) already names a skill in that workspace appends a version to it, and each item may carry its own `repo_id` and source envelope. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
      * Create many skills from bundles
      */
     skillBulkCreateRaw(requestParameters: SkillBulkCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SkillBulkSkillResponse>>;
     /**
-     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose `name` already names a skill in that workspace appends a version to it. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
+     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose identity (`source_id` when sent, else `name`) already names a skill in that workspace appends a version to it, and each item may carry its own `repo_id` and source envelope. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
      * Create many skills from bundles
      */
     skillBulkCreate(requestParameters: SkillBulkCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SkillBulkSkillResponse>;
@@ -146,12 +153,12 @@ export declare class SkillApi extends runtime.BaseAPI {
      */
     skillCreateRequestOpts(requestParameters: SkillCreateRequest): Promise<runtime.RequestOpts>;
     /**
-     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** `name` is the skill\'s identity within its workspace: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its name for a fresh line.
+     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** The skill\'s identity within its workspace is `source_id` when the envelope carries one, else `name`: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its identity for a fresh line.  **Provenance rides the envelope.** The `metadata` part may also carry `repo_id` and the source envelope (`source_type`, `source_id`, `source_uri`, `source_version`, `source_created_at`/`source_created_by`, `source_last_modified_at`/`source_last_modified_by`, `source_synced_at`, `source_metadata`), exactly as the generic artifact route takes them. A git sync sends the repo-relative skill path as `source_id` with `source_type: git`, which is what binds the skill to its repository and lets two repositories each publish a skill of the same name.
      * Create a skill from a bundle
      */
     skillCreateRaw(requestParameters: SkillCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SkillSkillArtifactView>>;
     /**
-     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** `name` is the skill\'s identity within its workspace: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its name for a fresh line.
+     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** The skill\'s identity within its workspace is `source_id` when the envelope carries one, else `name`: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its identity for a fresh line.  **Provenance rides the envelope.** The `metadata` part may also carry `repo_id` and the source envelope (`source_type`, `source_id`, `source_uri`, `source_version`, `source_created_at`/`source_created_by`, `source_last_modified_at`/`source_last_modified_by`, `source_synced_at`, `source_metadata`), exactly as the generic artifact route takes them. A git sync sends the repo-relative skill path as `source_id` with `source_type: git`, which is what binds the skill to its repository and lets two repositories each publish a skill of the same name.
      * Create a skill from a bundle
      */
     skillCreate(requestParameters: SkillCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SkillSkillArtifactView>;
@@ -174,12 +181,12 @@ export declare class SkillApi extends runtime.BaseAPI {
      */
     skillGetEnrichedRequestOpts(requestParameters: SkillGetEnrichedRequest): Promise<runtime.RequestOpts>;
     /**
-     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list.
+     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list. `files` is empty for a skill whose bytes are not served — `blocked` or `archived` — because the list names each file\'s directly fetchable content route; read `artifact_status` and, for a block, the skill\'s `security` insight.
      * Read a skill with its files\' L1 embedded
      */
     skillGetEnrichedRaw(requestParameters: SkillGetEnrichedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
     /**
-     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list.
+     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list. `files` is empty for a skill whose bytes are not served — `blocked` or `archived` — because the list names each file\'s directly fetchable content route; read `artifact_status` and, for a block, the skill\'s `security` insight.
      * Read a skill with its files\' L1 embedded
      */
     skillGetEnriched(requestParameters: SkillGetEnrichedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
@@ -216,12 +223,12 @@ export declare class SkillApi extends runtime.BaseAPI {
      */
     skillGetVersionEnrichedRequestOpts(requestParameters: SkillGetVersionEnrichedRequest): Promise<runtime.RequestOpts>;
     /**
-     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest.
+     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest. `files` is empty when the skill is `blocked` or `archived`, as on the latest read.
      * Read a pinned skill version with its files\' L1 embedded
      */
     skillGetVersionEnrichedRaw(requestParameters: SkillGetVersionEnrichedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
     /**
-     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest.
+     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest. `files` is empty when the skill is `blocked` or `archived`, as on the latest read.
      * Read a pinned skill version with its files\' L1 embedded
      */
     skillGetVersionEnriched(requestParameters: SkillGetVersionEnrichedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
@@ -244,12 +251,12 @@ export declare class SkillApi extends runtime.BaseAPI {
      */
     skillListRequestOpts(requestParameters: SkillListRequest): Promise<runtime.RequestOpts>;
     /**
-     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns.
+     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns; `workspace_id` narrows to one workspace and takes the prefixed `workspace_…` handle, the same spelling `POST /skills/search` and `POST /skills/aggregate` take. Without it the page spans every workspace the caller can read.
      * List skills
      */
     skillListRaw(requestParameters: SkillListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SkillPageSkillArtifactView>>;
     /**
-     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns.
+     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns; `workspace_id` narrows to one workspace and takes the prefixed `workspace_…` handle, the same spelling `POST /skills/search` and `POST /skills/aggregate` take. Without it the page spans every workspace the caller can read.
      * List skills
      */
     skillList(requestParameters?: SkillListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SkillPageSkillArtifactView>;
@@ -338,3 +345,51 @@ export declare class SkillApi extends runtime.BaseAPI {
      */
     skillSearch(requestParameters: SkillSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SkillPageSkillArtifactView>;
 }
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum SkillAggregateContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum SkillBulkCreateContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum SkillCreateContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum SkillPatchContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum SkillQuerySkillTraceStatsContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum SkillSearchContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}

package/dist/raw/skill/apis/SkillApi.js

@@ -46,7 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SkillApi = void 0;
+exports.SkillSearchContentEncodingEnum = exports.SkillQuerySkillTraceStatsContentEncodingEnum = exports.SkillPatchContentEncodingEnum = exports.SkillCreateContentEncodingEnum = exports.SkillBulkCreateContentEncodingEnum = exports.SkillAggregateContentEncodingEnum = exports.SkillApi = void 0;
 const runtime = __importStar(require("../runtime"));
 const GatewayTraceStatsEnvelope_1 = require("../models/GatewayTraceStatsEnvelope");
 const GatewayTraceStatsRequest_1 = require("../models/GatewayTraceStatsRequest");
@@ -74,6 +74,9 @@ class SkillApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -158,6 +161,9 @@ class SkillApi extends runtime.BaseAPI {
         }
         const queryParameters = {};
         const headerParameters = {};
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -191,7 +197,7 @@ class SkillApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose `name` already names a skill in that workspace appends a version to it. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
+     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose identity (`source_id` when sent, else `name`) already names a skill in that workspace appends a version to it, and each item may carry its own `repo_id` and source envelope. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
      * Create many skills from bundles
      */
     async skillBulkCreateRaw(requestParameters, initOverrides) {
@@ -200,7 +206,7 @@ class SkillApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SkillBulkSkillResponse_1.SkillBulkSkillResponseFromJSON)(jsonValue));
     }
     /**
-     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose `name` already names a skill in that workspace appends a version to it. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
+     * Upload up to 100 skill bundles in one `multipart/form-data` request. Send an `items` part holding a JSON array of `{metadata, body_part}` objects — `metadata` is the same envelope `POST /skills` takes (`name`, optional `description`, the required `workspace_id`), and `body_part` names another part of the same request carrying that skill\'s `.zip`. Each bundle runs the identical create flow to the single-upload route, and every skill\'s files are stored as content-addressed `file` artifacts in the same batch.  Re-uploading versions rather than duplicates, exactly as `POST /skills` does: an item whose identity (`source_id` when sent, else `name`) already names a skill in that workspace appends a version to it, and each item may carry its own `repo_id` and source envelope. Two items in one batch naming the same skill is a per-item `409` — a batch cannot append twice to one line. A byte-identical item is also a `409`, carrying `existing_artifact_id` so the caller can identify the skill it already has.  The response is `207 Multi-Status`: one slot per submitted item, in submitted order, each carrying either the created skill or an RFC 7807 problem. An item-attributable failure — a bundle that fails validation, a missing `body_part`, an unparseable envelope — is reported in that item\'s slot and does not affect the others. Only envelope-level failures (a malformed request, an `items` part that is missing, empty, or over the cap) fail the whole request.  The practical ceiling is usually the 16 MiB request body rather than the 100-item cap, since one bundle may itself be up to 10 MiB: batch small text bundles freely, and send large ones through `POST /skills` instead. A bundle containing one file whose *decompressed* size exceeds 16 MiB is a per-item `422` on that skill alone — a single file is stored in one call and cannot be split.
      * Create many skills from bundles
      */
     async skillBulkCreate(requestParameters, initOverrides) {
@@ -219,6 +225,9 @@ class SkillApi extends runtime.BaseAPI {
         }
         const queryParameters = {};
         const headerParameters = {};
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -257,7 +266,7 @@ class SkillApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** `name` is the skill\'s identity within its workspace: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its name for a fresh line.
+     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** The skill\'s identity within its workspace is `source_id` when the envelope carries one, else `name`: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its identity for a fresh line.  **Provenance rides the envelope.** The `metadata` part may also carry `repo_id` and the source envelope (`source_type`, `source_id`, `source_uri`, `source_version`, `source_created_at`/`source_created_by`, `source_last_modified_at`/`source_last_modified_by`, `source_synced_at`, `source_metadata`), exactly as the generic artifact route takes them. A git sync sends the repo-relative skill path as `source_id` with `source_type: git`, which is what binds the skill to its repository and lets two repositories each publish a skill of the same name.
      * Create a skill from a bundle
      */
     async skillCreateRaw(requestParameters, initOverrides) {
@@ -266,7 +275,7 @@ class SkillApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SkillSkillArtifactView_1.SkillSkillArtifactViewFromJSON)(jsonValue));
     }
     /**
-     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** `name` is the skill\'s identity within its workspace: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its name for a fresh line.
+     * Upload a skill bundle as `multipart/form-data`: a `metadata` JSON part carrying `name`, optional `description`, and the required `workspace_id` handle, plus a `body` part holding the `.zip`. The create hook unzips the bundle, validates it (rejecting zip-slip and requiring `SKILL.md`), derives `summary`/`license`/the structural counts, stores each file as its own content-addressed `file` artifact, and pins the manifest — so the skill\'s own properties are derived, never supplied.  **Re-uploading a skill versions it.** The skill\'s identity within its workspace is `source_id` when the envelope carries one, else `name`: a create naming a skill that already lives there appends a new version to that line rather than minting a second one, so the handle is stable across uploads and the history sits on one artifact. A byte-identical re-upload is an idempotent no-op that returns the existing head with no new version. Archiving a skill frees its identity for a fresh line.  **Provenance rides the envelope.** The `metadata` part may also carry `repo_id` and the source envelope (`source_type`, `source_id`, `source_uri`, `source_version`, `source_created_at`/`source_created_by`, `source_last_modified_at`/`source_last_modified_by`, `source_synced_at`, `source_metadata`), exactly as the generic artifact route takes them. A git sync sends the repo-relative skill path as `source_id` with `source_type: git`, which is what binds the skill to its repository and lets two repositories each publish a skill of the same name.
      * Create a skill from a bundle
      */
     async skillCreate(requestParameters, initOverrides) {
@@ -341,7 +350,7 @@ class SkillApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list.
+     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list. `files` is empty for a skill whose bytes are not served — `blocked` or `archived` — because the list names each file\'s directly fetchable content route; read `artifact_status` and, for a block, the skill\'s `security` insight.
      * Read a skill with its files\' L1 embedded
      */
     async skillGetEnrichedRaw(requestParameters, initOverrides) {
@@ -350,7 +359,7 @@ class SkillApi extends runtime.BaseAPI {
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list.
+     * Return the skill\'s latest view with each pinned file\'s L1 metadata embedded under `files` (content excluded). Each embedded file\'s `content_uri` is the file extension\'s HTTP content route, directly fetchable. The thin pin manifest is replaced by this richer list. `files` is empty for a skill whose bytes are not served — `blocked` or `archived` — because the list names each file\'s directly fetchable content route; read `artifact_status` and, for a block, the skill\'s `security` insight.
      * Read a skill with its files\' L1 embedded
      */
     async skillGetEnriched(requestParameters, initOverrides) {
@@ -481,7 +490,7 @@ class SkillApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest.
+     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest. `files` is empty when the skill is `blocked` or `archived`, as on the latest read.
      * Read a pinned skill version with its files\' L1 embedded
      */
     async skillGetVersionEnrichedRaw(requestParameters, initOverrides) {
@@ -490,7 +499,7 @@ class SkillApi extends runtime.BaseAPI {
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest.
+     * Like the latest read, but for a pinned skill version — the embedded file L1s are the exact versions that skill version pins, not file-latest. `files` is empty when the skill is `blocked` or `archived`, as on the latest read.
      * Read a pinned skill version with its files\' L1 embedded
      */
     async skillGetVersionEnriched(requestParameters, initOverrides) {
@@ -550,6 +559,9 @@ class SkillApi extends runtime.BaseAPI {
         if (requestParameters['skillVersion'] != null) {
             queryParameters['skill_version'] = requestParameters['skillVersion'];
         }
+        if (requestParameters['workspaceId'] != null) {
+            queryParameters['workspace_id'] = requestParameters['workspaceId'];
+        }
         if (requestParameters['sort'] != null) {
             queryParameters['sort'] = requestParameters['sort'];
         }
@@ -570,7 +582,7 @@ class SkillApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns.
+     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns; `workspace_id` narrows to one workspace and takes the prefixed `workspace_…` handle, the same spelling `POST /skills/search` and `POST /skills/aggregate` take. Without it the page spans every workspace the caller can read.
      * List skills
      */
     async skillListRaw(requestParameters, initOverrides) {
@@ -579,7 +591,7 @@ class SkillApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SkillPageSkillArtifactView_1.SkillPageSkillArtifactViewFromJSON)(jsonValue));
     }
     /**
-     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns.
+     * Page the account\'s skills, newest first, each carrying its typed metadata. System skills (the seeded bootstrap skill) are excluded. `license` and `skill_version` filter on the kind\'s indexed columns; `workspace_id` narrows to one workspace and takes the prefixed `workspace_…` handle, the same spelling `POST /skills/search` and `POST /skills/aggregate` take. Without it the page spans every workspace the caller can read.
      * List skills
      */
     async skillList(requestParameters = {}, initOverrides) {
@@ -764,6 +776,9 @@ class SkillApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -814,6 +829,9 @@ class SkillApi extends runtime.BaseAPI {
         }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -858,6 +876,9 @@ class SkillApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -893,3 +914,57 @@ class SkillApi extends runtime.BaseAPI {
     }
 }
 exports.SkillApi = SkillApi;
+/**
+  * @export
+  * @enum {string}
+  */
+var SkillAggregateContentEncodingEnum;
+(function (SkillAggregateContentEncodingEnum) {
+    SkillAggregateContentEncodingEnum["Base64"] = "base64";
+    SkillAggregateContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(SkillAggregateContentEncodingEnum || (exports.SkillAggregateContentEncodingEnum = SkillAggregateContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var SkillBulkCreateContentEncodingEnum;
+(function (SkillBulkCreateContentEncodingEnum) {
+    SkillBulkCreateContentEncodingEnum["Base64"] = "base64";
+    SkillBulkCreateContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(SkillBulkCreateContentEncodingEnum || (exports.SkillBulkCreateContentEncodingEnum = SkillBulkCreateContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var SkillCreateContentEncodingEnum;
+(function (SkillCreateContentEncodingEnum) {
+    SkillCreateContentEncodingEnum["Base64"] = "base64";
+    SkillCreateContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(SkillCreateContentEncodingEnum || (exports.SkillCreateContentEncodingEnum = SkillCreateContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var SkillPatchContentEncodingEnum;
+(function (SkillPatchContentEncodingEnum) {
+    SkillPatchContentEncodingEnum["Base64"] = "base64";
+    SkillPatchContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(SkillPatchContentEncodingEnum || (exports.SkillPatchContentEncodingEnum = SkillPatchContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var SkillQuerySkillTraceStatsContentEncodingEnum;
+(function (SkillQuerySkillTraceStatsContentEncodingEnum) {
+    SkillQuerySkillTraceStatsContentEncodingEnum["Base64"] = "base64";
+    SkillQuerySkillTraceStatsContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(SkillQuerySkillTraceStatsContentEncodingEnum || (exports.SkillQuerySkillTraceStatsContentEncodingEnum = SkillQuerySkillTraceStatsContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var SkillSearchContentEncodingEnum;
+(function (SkillSearchContentEncodingEnum) {
+    SkillSearchContentEncodingEnum["Base64"] = "base64";
+    SkillSearchContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(SkillSearchContentEncodingEnum || (exports.SkillSearchContentEncodingEnum = SkillSearchContentEncodingEnum = {}));

package/dist/raw/skill/models/GatewayArtifactBase.d.ts

@@ -16,6 +16,12 @@ import type { GatewayArtifactIdentityRevealView } from './GatewayArtifactIdentit
  * @interface GatewayArtifactBase
  */
 export interface GatewayArtifactBase {
+    /**
+     * Value of the `app` field.
+     * @type {string}
+     * @memberof GatewayArtifactBase
+     */
+    app?: string;
     /**
      * Value of the `artifact_status` field.
      * @type {string}
@@ -58,12 +64,6 @@ export interface GatewayArtifactBase {
      * @memberof GatewayArtifactBase
      */
     displayName?: string;
-    /**
-     * Value of the `extension` field.
-     * @type {string}
-     * @memberof GatewayArtifactBase
-     */
-    extension?: string;
     /**
      * Kind-prefixed Crockford-base32 handle (`<kind>_<base32>`).
      * @type {string}
@@ -102,19 +102,28 @@ export interface GatewayArtifactBase {
      * The Control-Plane OIDC client id this artifact authenticates as
      * (`x-gateway-identity` kinds); absent for every other kind.
      *
-     * **Derived, not stored.** The registry resolves it from the artifact's
-     * `service_principals` row rather than keeping a second copy on the artifact,
-     * so it appears on the create response and on the single-artifact read — the
-     * two paths that make that lookup — and **not** on list, search, or a `PATCH`
-     * response, none of which do a per-row identity read. It is the public half of
-     * the credential pair and is not secret.
+     * **Derived, not stored, and present on the create response only.** The
+     * registry would resolve it from the artifact's `service_principals` row
+     * rather than keep a second copy on the artifact — but only the create path
+     * does that lookup, because it has just provisioned the identity. Every read
+     * shape (single read, list, search, `PATCH`) is built by one constructor that
+     * sets this `None`, so it is absent from all four.
+     *
+     * This block used to name the single-artifact read as a second populated path.
+     * It was never one. Adding it means deciding whether list and search pay a
+     * per-row identity read too; the lookup a future implementation would call is
+     * `registry_server::identity::artifact_principal`. It is the public half of the
+     * credential pair and is not secret.
      * @type {string}
      * @memberof GatewayArtifactBase
      */
     oidcClientId?: string | null;
     /**
      * Canonical owner: the `users.user_id` this artifact belongs to, FK-backed.
-     * Absent when unset (legacy rows / system-plane creates).
+     *
+     * Defaulted to the creating principal, so this is normally set. Absent for a row created
+     * before that default landed, for a system-plane write, and for a principal with no directory
+     * row — a service account or a seed has nothing to own anything with.
      * @type {string}
      * @memberof GatewayArtifactBase
      */
@@ -222,13 +231,16 @@ export interface GatewayArtifactBase {
      */
     updatedBy: string;
     /**
-     * Optional human version selector (semver); absent when unset.
+     * The free-form label the write set, verbatim. Absent when none was sent, and *not* the name
+     * the version shipped under — that is the release's own `version_label`.
      * @type {string}
      * @memberof GatewayArtifactBase
      */
     versionLabel?: string | null;
     /**
-     * Monotonic version coordinate within the artifact line.
+     * This version's position in its line — the write index, 1-based and dense over versions
+     * *written*. Distinct from a release's `version_ordinal`, which counts versions **shipped**;
+     * the two agree under the default `auto` release policy and diverge under `manual`.
      * @type {number}
      * @memberof GatewayArtifactBase
      */

package/dist/raw/skill/models/GatewayArtifactBase.js

@@ -59,6 +59,7 @@ function GatewayArtifactBaseFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'app': json['app'] == null ? undefined : json['app'],
         'artifactStatus': json['artifact_status'],
         'commitTs': json['commit_ts'],
         'contentHashHex': json['content_hash_hex'] === undefined ? undefined : json['content_hash_hex'] === null ? null : json['content_hash_hex'],
@@ -66,7 +67,6 @@ function GatewayArtifactBaseFromJSONTyped(json, ignoreDiscriminator) {
         'createdBy': json['created_by'],
         'description': json['description'] === undefined ? undefined : json['description'] === null ? null : json['description'],
         'displayName': json['display_name'] == null ? undefined : json['display_name'],
-        'extension': json['extension'] == null ? undefined : json['extension'],
         'id': json['id'],
         'identity': json['identity'] === undefined ? undefined : json['identity'] === null ? null : (0, GatewayArtifactIdentityRevealView_1.GatewayArtifactIdentityRevealViewFromJSON)(json['identity']),
         'isLatest': json['is_latest'],
@@ -102,6 +102,7 @@ function GatewayArtifactBaseToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'app': value['app'],
         'artifact_status': value['artifactStatus'],
         'commit_ts': value['commitTs'],
         'content_hash_hex': value['contentHashHex'],
@@ -109,7 +110,6 @@ function GatewayArtifactBaseToJSONTyped(value, ignoreDiscriminator = false) {
         'created_by': value['createdBy'],
         'description': value['description'],
         'display_name': value['displayName'],
-        'extension': value['extension'],
         'id': value['id'],
         'identity': (0, GatewayArtifactIdentityRevealView_1.GatewayArtifactIdentityRevealViewToJSON)(value['identity']),
         'is_latest': value['isLatest'],

package/dist/raw/skill/models/GatewayTraceStatsGroupBy.d.ts

@@ -22,7 +22,11 @@ export declare enum GatewayTraceStatsGroupBy {
     Mcp = "mcp",
     Tool = "tool",
     Model = "model",
-    User = "user"
+    User = "user",
+    Experiment = "experiment",
+    ScoreName = "score_name",
+    Scorer = "scorer",
+    ScorerVersion = "scorer_version"
 }
 export declare function instanceOfGatewayTraceStatsGroupBy(value: any): boolean;
 export declare function GatewayTraceStatsGroupByFromJSON(json: any): GatewayTraceStatsGroupBy;

package/dist/raw/skill/models/GatewayTraceStatsGroupBy.js

@@ -34,6 +34,10 @@ var GatewayTraceStatsGroupBy;
     GatewayTraceStatsGroupBy["Tool"] = "tool";
     GatewayTraceStatsGroupBy["Model"] = "model";
     GatewayTraceStatsGroupBy["User"] = "user";
+    GatewayTraceStatsGroupBy["Experiment"] = "experiment";
+    GatewayTraceStatsGroupBy["ScoreName"] = "score_name";
+    GatewayTraceStatsGroupBy["Scorer"] = "scorer";
+    GatewayTraceStatsGroupBy["ScorerVersion"] = "scorer_version";
 })(GatewayTraceStatsGroupBy || (exports.GatewayTraceStatsGroupBy = GatewayTraceStatsGroupBy = {}));
 function instanceOfGatewayTraceStatsGroupBy(value) {
     for (const key in GatewayTraceStatsGroupBy) {

package/dist/raw/skill/models/GatewayTraceStatsMeasure.d.ts

@@ -28,7 +28,9 @@ export declare enum GatewayTraceStatsMeasure {
     Cost = "cost",
     LatencyP50 = "latency_p50",
     LatencyP90 = "latency_p90",
-    LatencyP99 = "latency_p99"
+    LatencyP99 = "latency_p99",
+    ScoreValue = "score_value",
+    Scores = "scores"
 }
 export declare function instanceOfGatewayTraceStatsMeasure(value: any): boolean;
 export declare function GatewayTraceStatsMeasureFromJSON(json: any): GatewayTraceStatsMeasure;

package/dist/raw/skill/models/GatewayTraceStatsMeasure.js

@@ -40,6 +40,8 @@ var GatewayTraceStatsMeasure;
     GatewayTraceStatsMeasure["LatencyP50"] = "latency_p50";
     GatewayTraceStatsMeasure["LatencyP90"] = "latency_p90";
     GatewayTraceStatsMeasure["LatencyP99"] = "latency_p99";
+    GatewayTraceStatsMeasure["ScoreValue"] = "score_value";
+    GatewayTraceStatsMeasure["Scores"] = "scores";
 })(GatewayTraceStatsMeasure || (exports.GatewayTraceStatsMeasure = GatewayTraceStatsMeasure = {}));
 function instanceOfGatewayTraceStatsMeasure(value) {
     for (const key in GatewayTraceStatsMeasure) {

package/dist/raw/skill/models/SkillAggregate400Response.d.ts

@@ -51,6 +51,8 @@ export interface SkillAggregate400Response {
 * @enum {string}
 */
 export declare enum SkillAggregate400ResponseCodeEnum {
+    InvalidBase64 = "invalid_base64",
+    InvalidGzip = "invalid_gzip",
     InvalidJson = "invalid_json"
 }
 /**

package/dist/raw/skill/models/SkillAggregate400Response.js

@@ -25,6 +25,8 @@ exports.SkillAggregate400ResponseToJSONTyped = SkillAggregate400ResponseToJSONTy
 */
 var SkillAggregate400ResponseCodeEnum;
 (function (SkillAggregate400ResponseCodeEnum) {
+    SkillAggregate400ResponseCodeEnum["InvalidBase64"] = "invalid_base64";
+    SkillAggregate400ResponseCodeEnum["InvalidGzip"] = "invalid_gzip";
     SkillAggregate400ResponseCodeEnum["InvalidJson"] = "invalid_json";
 })(SkillAggregate400ResponseCodeEnum || (exports.SkillAggregate400ResponseCodeEnum = SkillAggregate400ResponseCodeEnum = {}));
 /**
@@ -33,8 +35,6 @@ var SkillAggregate400ResponseCodeEnum;
 function instanceOfSkillAggregate400Response(value) {
     if (!('code' in value) || value['code'] === undefined)
         return false;
-    if (value['code'] !== 'invalid_json')
-        return false;
     if (!('detail' in value) || value['detail'] === undefined)
         return false;
     if (!('status' in value) || value['status'] === undefined)