hanzoai 8.5.621 → 8.5.640

package/src/api/auto-api.ts

@@ -30,6 +30,8 @@ import type { AutoAutomationPage } from '../models';
 // @ts-ignore
 import type { AutoAutomationPatch } from '../models';
 // @ts-ignore
+import type { AutoAutomationRun } from '../models';
+// @ts-ignore
 import type { AutoAutomationRunPage } from '../models';
 // @ts-ignore
 import type { AutoCatalog } from '../models';
@@ -50,6 +52,8 @@ import type { AutoPatchFlowIn } from '../models';
 // @ts-ignore
 import type { AutoPopulatedFlow } from '../models';
 // @ts-ignore
+import type { AutoReviewIn } from '../models';
+// @ts-ignore
 import type { AutoRunIn } from '../models';
 // @ts-ignore
 import type { AutoRunPage } from '../models';
@@ -706,6 +710,54 @@ export const AutoApiAxiosParamCreator = function (configuration?: Configuration)
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+         * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+         * @param {string} id ID is the automation, and Run its run in review, from the path.
+         * @param {string} run 
+         * @param {AutoReviewIn} autoReviewIn 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postAutoAutomationsByIdRunsByRunReview: async (id: string, run: string, autoReviewIn: AutoReviewIn, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('postAutoAutomationsByIdRunsByRunReview', 'id', id)
+            // verify required parameter 'run' is not null or undefined
+            assertParamExists('postAutoAutomationsByIdRunsByRunReview', 'run', run)
+            // verify required parameter 'autoReviewIn' is not null or undefined
+            assertParamExists('postAutoAutomationsByIdRunsByRunReview', 'autoReviewIn', autoReviewIn)
+            const localVarPath = `/v1/auto/automations/{id}/runs/{run}/review`
+                .replace(`{${"id"}}`, encodeURIComponent(String(id)))
+                .replace(`{${"run"}}`, encodeURIComponent(String(run)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(autoReviewIn, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
          * @summary Creates an automation and its initial DRAFT version in one call.
@@ -1288,6 +1340,21 @@ export const AutoApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['AutoApi.postAutoAutomationsByIdRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+         * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+         * @param {string} id ID is the automation, and Run its run in review, from the path.
+         * @param {string} run 
+         * @param {AutoReviewIn} autoReviewIn 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async postAutoAutomationsByIdRunsByRunReview(id: string, run: string, autoReviewIn: AutoReviewIn, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AutoAutomationRun>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.postAutoAutomationsByIdRunsByRunReview(id, run, autoReviewIn, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AutoApi.postAutoAutomationsByIdRunsByRunReview']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
          * @summary Creates an automation and its initial DRAFT version in one call.
@@ -1576,6 +1643,16 @@ export const AutoApiFactory = function (configuration?: Configuration, basePath?
         postAutoAutomationsByIdRun(requestParameters: AutoApiPostAutoAutomationsByIdRunRequest, options?: RawAxiosRequestConfig): AxiosPromise<AutoRunStarted> {
             return localVarFp.postAutoAutomationsByIdRun(requestParameters.id, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+         * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+         * @param {AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest} requestParameters Request parameters.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postAutoAutomationsByIdRunsByRunReview(requestParameters: AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest, options?: RawAxiosRequestConfig): AxiosPromise<AutoAutomationRun> {
+            return localVarFp.postAutoAutomationsByIdRunsByRunReview(requestParameters.id, requestParameters.run, requestParameters.autoReviewIn, options).then((request) => request(axios, basePath));
+        },
         /**
          * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
          * @summary Creates an automation and its initial DRAFT version in one call.
@@ -1907,6 +1984,34 @@ export interface AutoApiPostAutoAutomationsByIdRunRequest {
     readonly id: string
 }
 
+/**
+ * Request parameters for postAutoAutomationsByIdRunsByRunReview operation in AutoApi.
+ * @export
+ * @interface AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest
+ */
+export interface AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest {
+    /**
+     * ID is the automation, and Run its run in review, from the path.
+     * @type {string}
+     * @memberof AutoApiPostAutoAutomationsByIdRunsByRunReview
+     */
+    readonly id: string
+
+    /**
+     * 
+     * @type {string}
+     * @memberof AutoApiPostAutoAutomationsByIdRunsByRunReview
+     */
+    readonly run: string
+
+    /**
+     * 
+     * @type {AutoReviewIn}
+     * @memberof AutoApiPostAutoAutomationsByIdRunsByRunReview
+     */
+    readonly autoReviewIn: AutoReviewIn
+}
+
 /**
  * Request parameters for postAutoFlows operation in AutoApi.
  * @export
@@ -2251,6 +2356,18 @@ export class AutoApi extends BaseAPI {
         return AutoApiFp(this.configuration).postAutoAutomationsByIdRun(requestParameters.id, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+     * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+     * @param {AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AutoApi
+     */
+    public postAutoAutomationsByIdRunsByRunReview(requestParameters: AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest, options?: RawAxiosRequestConfig) {
+        return AutoApiFp(this.configuration).postAutoAutomationsByIdRunsByRunReview(requestParameters.id, requestParameters.run, requestParameters.autoReviewIn, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
      * @summary Creates an automation and its initial DRAFT version in one call.

package/src/api/billing-api.ts

@@ -460,7 +460,7 @@ export const BillingApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
          * @summary Prepaid credit the caller\'s org can still spend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2094,7 +2094,7 @@ export const BillingApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
          * @summary Prepaid credit the caller\'s org can still spend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2701,7 +2701,7 @@ export const BillingApiFactory = function (configuration?: Configuration, basePa
             return localVarFp.getBillingAlertsAuthorize(requestParameters.project, requestParameters.service, requestParameters.amount, requestParameters.pv, options).then((request) => request(axios, basePath));
         },
         /**
-         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
          * @summary Prepaid credit the caller\'s org can still spend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -3658,7 +3658,7 @@ export class BillingApi extends BaseAPI {
     }
 
     /**
-     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
      * @summary Prepaid credit the caller\'s org can still spend
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/src/api/git-api.ts

@@ -92,6 +92,8 @@ import type { GitWorkflowRun } from '../models';
 // @ts-ignore
 import type { GitWorkflowRuns } from '../models';
 // @ts-ignore
+import type { GitWorkspaceView } from '../models';
+// @ts-ignore
 import type { ProblemDetails } from '../models';
 // @ts-ignore
 import type { RunnerDeclareIn } from '../models';
@@ -2013,6 +2015,40 @@ export const GitApiAxiosParamCreator = function (configuration?: Configuration)
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+         * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postGitWorkspace: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/v1/git/workspace`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -2892,6 +2928,18 @@ export const GitApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['GitApi.postGitWebhook']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+         * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async postGitWorkspace(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GitWorkspaceView>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.postGitWorkspace(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['GitApi.postGitWorkspace']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
          * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -3427,6 +3475,15 @@ export const GitApiFactory = function (configuration?: Configuration, basePath?:
         postGitWebhook(options?: RawAxiosRequestConfig): AxiosPromise<void> {
             return localVarFp.postGitWebhook(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+         * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postGitWorkspace(options?: RawAxiosRequestConfig): AxiosPromise<GitWorkspaceView> {
+            return localVarFp.postGitWorkspace(options).then((request) => request(axios, basePath));
+        },
         /**
          * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
          * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -4955,6 +5012,17 @@ export class GitApi extends BaseAPI {
         return GitApiFp(this.configuration).postGitWebhook(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+     * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof GitApi
+     */
+    public postGitWorkspace(options?: RawAxiosRequestConfig) {
+        return GitApiFp(this.configuration).postGitWorkspace(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
      * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.

package/src/api/task-api.ts

@@ -26,6 +26,8 @@ import type { ProblemDetails } from '../models';
 // @ts-ignore
 import type { TaskBoardView } from '../models';
 // @ts-ignore
+import type { TaskCommentList } from '../models';
+// @ts-ignore
 import type { TaskIssueEdit } from '../models';
 // @ts-ignore
 import type { TaskIssueHit } from '../models';
@@ -402,6 +404,48 @@ export const TaskApiAxiosParamCreator = function (configuration?: Configuration)
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+         * @summary Is one issue\'s conversation, oldest first, read as the caller.
+         * @param {string} key Key is the board — the repository name, or an index board\'s key.
+         * @param {number} num Num is the issue\'s number on that board.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getTaskProjectsByKeyIssuesByNumComments: async (key: string, num: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'key' is not null or undefined
+            assertParamExists('getTaskProjectsByKeyIssuesByNumComments', 'key', key)
+            // verify required parameter 'num' is not null or undefined
+            assertParamExists('getTaskProjectsByKeyIssuesByNumComments', 'num', num)
+            const localVarPath = `/v1/task/projects/{key}/issues/{num}/comments`
+                .replace(`{${"key"}}`, encodeURIComponent(String(key)))
+                .replace(`{${"num"}}`, encodeURIComponent(String(num)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -776,6 +820,20 @@ export const TaskApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['TaskApi.getTaskProjectsByKeyIssuesByNum']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+         * @summary Is one issue\'s conversation, oldest first, read as the caller.
+         * @param {string} key Key is the board — the repository name, or an index board\&#39;s key.
+         * @param {number} num Num is the issue\&#39;s number on that board.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getTaskProjectsByKeyIssuesByNumComments(key: string, num: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TaskCommentList>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTaskProjectsByKeyIssuesByNumComments(key, num, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TaskApi.getTaskProjectsByKeyIssuesByNumComments']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
          * @summary Summarises one room\'s work.
@@ -936,6 +994,16 @@ export const TaskApiFactory = function (configuration?: Configuration, basePath?
         getTaskProjectsByKeyIssuesByNum(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumRequest, options?: RawAxiosRequestConfig): AxiosPromise<TaskIssueView> {
             return localVarFp.getTaskProjectsByKeyIssuesByNum(requestParameters.key, requestParameters.num, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+         * @summary Is one issue\'s conversation, oldest first, read as the caller.
+         * @param {TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest} requestParameters Request parameters.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getTaskProjectsByKeyIssuesByNumComments(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest, options?: RawAxiosRequestConfig): AxiosPromise<TaskCommentList> {
+            return localVarFp.getTaskProjectsByKeyIssuesByNumComments(requestParameters.key, requestParameters.num, options).then((request) => request(axios, basePath));
+        },
         /**
          * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
          * @summary Summarises one room\'s work.
@@ -1229,6 +1297,27 @@ export interface TaskApiGetTaskProjectsByKeyIssuesByNumRequest {
     readonly num: number
 }
 
+/**
+ * Request parameters for getTaskProjectsByKeyIssuesByNumComments operation in TaskApi.
+ * @export
+ * @interface TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest
+ */
+export interface TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest {
+    /**
+     * Key is the board — the repository name, or an index board\&#39;s key.
+     * @type {string}
+     * @memberof TaskApiGetTaskProjectsByKeyIssuesByNumComments
+     */
+    readonly key: string
+
+    /**
+     * Num is the issue\&#39;s number on that board.
+     * @type {number}
+     * @memberof TaskApiGetTaskProjectsByKeyIssuesByNumComments
+     */
+    readonly num: number
+}
+
 /**
  * Request parameters for getTaskRoomsByRoom operation in TaskApi.
  * @export
@@ -1417,6 +1506,18 @@ export class TaskApi extends BaseAPI {
         return TaskApiFp(this.configuration).getTaskProjectsByKeyIssuesByNum(requestParameters.key, requestParameters.num, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+     * @summary Is one issue\'s conversation, oldest first, read as the caller.
+     * @param {TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TaskApi
+     */
+    public getTaskProjectsByKeyIssuesByNumComments(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest, options?: RawAxiosRequestConfig) {
+        return TaskApiFp(this.configuration).getTaskProjectsByKeyIssuesByNumComments(requestParameters.key, requestParameters.num, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
      * @summary Summarises one room\'s work.

package/src/client.ts

@@ -13,7 +13,7 @@
 // `client.configuration` and construct one with the same identity.
 
 import { Fault, type Call, type Query, type Reply } from './answer';
-import { Configuration } from './configuration';
+import { Configuration } from './transport';
 import { Audit } from './audit';
 import { Budget } from './budget';
 import { Graph } from './graph';
@@ -120,7 +120,8 @@ export class Client {
   /**
    * A Configuration carrying this client's identity, for the generated *Api
    * classes. The `accessToken` reader is a function, so every generated call
-   * mints or re-uses through the same cache the six use.
+   * mints or re-uses through the same cache the six use, and a usage refusal
+   * arrives as its typed error (transport.ts).
    */
   get configuration(): Configuration {
     return new Configuration({ basePath: this.base, accessToken: () => this.token() });

package/src/hanzo.ts

@@ -23,9 +23,27 @@
 
 export * from './index';
 
+// The generated Configuration, plus typed usage refusals on every *Api call
+// made with it. Named here, it shadows the one `./index` exports.
+export { Configuration } from './transport';
+
 export { Client } from './client';
 export type { Options } from './client';
 
+// What a priced answer's headers say, and the six refusals a caller can act on —
+// the same names as the Python and Go SDKs.
+export {
+  readUsage,
+  UsageLimitError,
+  PlanAllowanceUsedError,
+  PaidPlanRequiredError,
+  FreePlanCapError,
+  ModelCapError,
+  UsageCapExceededError,
+  InsufficientBalanceError,
+} from './usage';
+export type { Usage, UsageAction, HeaderSource } from './usage';
+
 export * as answer from './answer';
 export * as budget from './budget';
 export * as policy from './policy';

package/src/models/agent-target-view.ts

@@ -80,6 +80,12 @@ export interface AgentTargetView {
      * @memberof AgentTargetView
      */
     'running'?: number;
+    /**
+     * Serving says whether a run the caller sends here now would be taken: the machine is the caller\'s (or the caller is an org admin), and it is online with a runner that polled for work within the last 90 seconds — the online and runner half is what dispatch checks (TargetDispatchable). A heartbeat alone keeps a machine online, not serving, and a colleague\'s machine never serves the caller.
+     * @type {boolean}
+     * @memberof AgentTargetView
+     */
+    'serving'?: boolean;
     /**
      * Sessions is how many of the org\'s sessions are mapped to this machine, by target id OR by matching Host. All of them, whatever their status.
      * @type {number}

package/src/models/ai-chat-in.ts

@@ -0,0 +1,48 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+
+/**
+ * 
+ * @export
+ * @interface AiChatIn
+ */
+export interface AiChatIn {
+    /**
+     * MaxTokens bounds the answer in tokens; 0 leaves it to the model.
+     * @type {number}
+     * @memberof AiChatIn
+     */
+    'max_tokens'?: number;
+    /**
+     * Model is the model to answer, by id (zen5, enso, kai, anthropic/claude-sonnet-4.5 — aiModels lists them). Empty asks the deployment\'s default Hanzo model.
+     * @type {string}
+     * @memberof AiChatIn
+     */
+    'model'?: string;
+    /**
+     * Prompt is what to ask.
+     * @type {string}
+     * @memberof AiChatIn
+     */
+    'prompt'?: string;
+    /**
+     * System is the system message ahead of the prompt, when set.
+     * @type {string}
+     * @memberof AiChatIn
+     */
+    'system'?: string;
+}
+

package/src/models/ai-chat.ts

@@ -0,0 +1,45 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Hanzo Cloud API
+ * The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator\'s admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+// May contain unused imports in some cases
+// @ts-ignore
+import type { AiReceipt } from './ai-receipt';
+
+/**
+ * 
+ * @export
+ * @interface AiChat
+ */
+export interface AiChat {
+    /**
+     * Answer is the model\'s reply.
+     * @type {string}
+     * @memberof AiChat
+     */
+    'answer'?: string;
+    /**
+     * Model is the model asked: the caller\'s, or the default when it named none.
+     * @type {string}
+     * @memberof AiChat
+     */
+    'model'?: string;
+    /**
+     * Receipt says which model served the reply and who paid for it.
+     * @type {AiReceipt}
+     * @memberof AiChat
+     */
+    'receipt'?: AiReceipt;
+}
+