@leaflow/sdk 0.27.0 → 0.29.0

package/dist/assistant/v1/schema.d.ts

@@ -934,6 +934,8 @@ export interface components {
         ContextResource: {
             /** Format: int64 */
             compactAt: number | null;
+            /** @description What kinds of input the model behind this conversation accepts, as modality names: text, image. A client uses this to decide whether a control exists — an attach button on a model that cannot read pictures is a control whose only outcome is a refusal, and the refusal arrives after somebody has chosen a file. An empty list is not a claim that the model reads nothing: it means this deployment has not stated the modalities, or the conversation names a model that has since been retired. Treat empty as unknown and keep the control, because hiding one for a reason nobody can see is worse than a refusal that says why. */
+            inputModalities: string[];
             model: string;
             /** Format: int64 */
             used: number | null;

package/dist/billing/v1/index.d.ts

@@ -6,10 +6,20 @@ export type ListBillingAccountsResult = operations["list-billing-accounts"]["res
 export type CreateBillingAccountResult = operations["create-billing-account"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts` 的请求体。 */
 export type CreateBillingAccountBody = NonNullable<operations["create-billing-account"]["requestBody"]>["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}` 成功时的响应体。 */
+export type GetBillingAccountResult = operations["get-billing-account"]["responses"][200]["content"]["application/json"];
+/** `PUT /account/v1/billing-accounts/{accountKey}` 成功时的响应体。 */
+export type UpdateBillingAccountResult = operations["update-billing-account"]["responses"][200]["content"]["application/json"];
+/** `PUT /account/v1/billing-accounts/{accountKey}` 的请求体。 */
+export type UpdateBillingAccountBody = NonNullable<operations["update-billing-account"]["requestBody"]>["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}/credit-transactions` 成功时的响应体。 */
+export type ListCreditTransactionsResult = operations["list-credit-transactions"]["responses"][200]["content"]["application/json"];
 /** `GET /account/v1/billing-accounts/{accountKey}/balance` 成功时的响应体。 */
 export type ReadBillingAccountBalanceResult = operations["read-billing-account-balance"]["responses"][200]["content"]["application/json"];
 /** `PUT /account/v1/billing-accounts/{accountKey}/projects/{projectId}` 成功时的响应体。 */
 export type BindProjectToBillingAccountResult = operations["bind-project-to-billing-account"]["responses"][200]["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}/top-ups` 成功时的响应体。 */
+export type ListTopUpsResult = operations["list-top-ups"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts/{accountKey}/top-ups` 成功时的响应体。 */
 export type StartTopUpResult = operations["start-top-up"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts/{accountKey}/top-ups` 的请求体。 */

package/dist/billing/v1/schema.d.ts

@@ -38,6 +38,63 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read one of my billing accounts
+         * @description One account, with the projects it currently pays for.
+         *
+         *     The list returns the same objects, so this exists for the case the list cannot serve: a link
+         *     straight to one account. Making the caller fetch every account and filter turns a bookmarked
+         *     page into a request whose cost grows with how many accounts they hold.
+         */
+        get: operations["get-billing-account"];
+        /**
+         * Rename a billing account
+         * @description Changes the display name. Nothing else about the account can be changed here.
+         *
+         *     The key is not among the fields and never will be: ownership is stated by the key, and
+         *     invoices already issued refer to it. The name is what tells two accounts apart in a list, so
+         *     a mistake made while creating one is otherwise permanent.
+         */
+        put: operations["update-billing-account"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/credit-transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * How the balance got to where it is
+         * @description Every movement of credit on this account: what was added, what was spent, what expired, what
+         *     was voided. Newest first.
+         *
+         *     The balance on its own is a number with no account of itself. Asked why it is lower than
+         *     expected, it cannot answer, and the holder is left to guess between "I was charged" and
+         *     "something expired" — which lead to different next steps.
+         */
+        get: operations["list-credit-transactions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/account/v1/billing-accounts/{accountKey}/balance": {
         parameters: {
             query?: never;
@@ -90,7 +147,21 @@ export interface paths {
          */
         put: operations["bind-project-to-billing-account"];
         post?: never;
-        delete?: never;
+        /**
+         * Stop paying for a project
+         * @description Unbinds the project from this account. Nothing pays for it afterwards, and **everything in it
+         *     is refused admission** until some account takes it on — no new machines, no forwarded
+         *     requests.
+         *
+         *     That consequence is the reason this exists rather than an argument against it: a project
+         *     bound to the wrong account has no other way out, and moving it to another of the caller's
+         *     accounts is not a correction when the answer is that this account should not be paying for
+         *     it at all.
+         *
+         *     Charges already accrued stay where they are. They were incurred while this account held the
+         *     project, and an invoice has to keep pointing at what it was based on.
+         */
+        delete: operations["unbind-project-from-billing-account"];
         options?: never;
         head?: never;
         patch?: never;
@@ -103,7 +174,16 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * My top-ups
+         * @description Every top-up this account has made, newest first.
+         *
+         *     Reading one top-up requires already holding its identifier, and the only place that
+         *     identifier appears is the redirect that started it — so without this list a top-up becomes
+         *     unfindable the moment the browser tab is closed, which is exactly when somebody wants to
+         *     check whether their money arrived.
+         */
+        get: operations["list-top-ups"];
         put?: never;
         /**
          * Start a top-up
@@ -485,6 +565,43 @@ export interface components {
              */
             one_time?: boolean;
         };
+        UpdateBillingAccountRequestBody: {
+            display_name: string;
+        };
+        TopUpList: {
+            top_ups: components["schemas"]["TopUpStatus"][];
+        };
+        CreditTransactionList: {
+            transactions: components["schemas"]["CreditTransaction"][];
+        };
+        /**
+         * @description One movement of credit. Immutable — a correction is another movement, never an edit of this
+         *     one, which is what lets the balance be recomputed from the list at any time
+         */
+        CreditTransaction: {
+            id: string;
+            type: components["schemas"]["CreditTransactionType"];
+            /** @description A decimal string. Never a float — a balance that rounds is a balance that drifts */
+            amount: string;
+            currency: string;
+            /**
+             * Format: date-time
+             * @description When it landed on the ledger, which is not always when it was requested
+             */
+            booked_at: string;
+            /**
+             * @description What the balance became. Recorded by the metering engine rather than recomputed here —
+             *     recomputing assumes our understanding of the burn-down order matches its own, and this
+             *     is its own account of it
+             */
+            balance_after: string;
+        };
+        /**
+         * @description `funded` is credit arriving, `consumed` is it being spent, `expired` is a grant reaching the
+         *     end of its life unspent, and `voided` is one cancelled — a refund, or a correction
+         * @enum {string}
+         */
+        CreditTransactionType: "funded" | "consumed" | "expired" | "voided";
         /**
          * @description What a top-up bundle costs and what it grants. Present only on offers that sell credit.
          *
@@ -731,11 +848,16 @@ export interface components {
             currency?: components["schemas"]["Currency"];
         };
         /**
-         * @description ISO 4217. `USD` is the only value the platform issues today; the field is carried so that an
-         *     amount is never ambiguous about what it is denominated in.
-         * @enum {string}
+         * @description ISO 4217, uppercase. `USD` is the only value the platform issues today, and a request
+         *     naming any other is refused with `BILLING_CURRENCY_UNSUPPORTED`.
+         *
+         *     Deliberately not an enumeration. The set of currency codes is governed outside this API, so
+         *     a client generated today must still be able to read a response naming a code added later —
+         *     an enumeration turns that response into a decode failure in a client nobody can redeploy.
+         *     Restricting what may be *sent* is a rule about what the platform supports, and it lives
+         *     where that rule can change without regenerating anything.
          */
-        Currency: "USD";
+        Currency: string;
     };
     responses: never;
     parameters: {
@@ -813,6 +935,115 @@ export interface operations {
             };
         };
     };
+    "get-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "update-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateBillingAccountRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-credit-transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreditTransactionList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "read-billing-account-balance": {
         parameters: {
             query?: never;
@@ -885,6 +1116,76 @@ export interface operations {
             };
         };
     };
+    "unbind-project-from-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description The project to stop paying for */
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Unbound */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-top-ups": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopUpList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "start-top-up": {
         parameters: {
             query?: never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leaflow/sdk",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "description": "Leaflow 平台 API 的 TypeScript SDK",
   "license": "MIT",
   "repository": {