@leaflow/sdk 0.141.0 → 0.143.0

package/dist/canopy/v1/generated/validators/quoteRequest.zod.d.ts

@@ -43,9 +43,12 @@ export declare const QuoteRequest: zod.ZodObject<{
         product_id: zod.ZodOptional<zod.ZodString>;
         plan_id: zod.ZodOptional<zod.ZodUUID>;
         price_type: zod.ZodOptional<zod.ZodEnum<{
-            postpaid: "postpaid";
-            prepaid: "prepaid";
             one_time: "one_time";
+            recurring: "recurring";
+        }>>;
+        usage_type: zod.ZodOptional<zod.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
         }>>;
         interval: zod.ZodOptional<zod.ZodEnum<{
             none: "none";

package/dist/canopy/v1/generated/validators/quoteRequest.zod.js

@@ -43,25 +43,25 @@ export const QuoteRequest = zod
     billing_account_id: zod
         .int()
         .min(1)
-        .describe("The billing account to price for. It must belong to you. Existing orders must have been purchased\nwith this account; renewals and cancellations must currently be paid for by it."),
+        .describe("The billing account to price for; it must be yours. Existing orders must have been placed with it, and renewals and cancellations must currently be paid by it."),
     items: zod
         .array(QuoteItemInput)
         .min(1)
         .max(quoteRequestItemsMax)
         .optional()
-        .describe("A proposed purchase priced in the account currency. Metered items may estimate specified usage\nquantities; those estimates are not amounts collectible at checkout."),
+        .describe("A proposed purchase priced in the account's currency. Metered items may include usage estimates, which are not checkout amounts."),
     order_id: zod
         .uuid()
         .optional()
-        .describe("Preview paying this existing order. Its recorded purchase terms supply every line, and an order\nwhose terms are fixed returns its recorded amounts. A preview does not change the order."),
+        .describe("Preview paying this order. Its recorded terms supply every line, and an order whose terms are fixed returns its recorded amounts. The order does not change."),
     renewals: zod
         .array(QuoteRenewal)
         .min(1)
         .max(quoteRequestRenewalsMax)
         .optional()
-        .describe("Preview renewing these subscriptions, each at most once. Each entry represents a separate\nrenewal order. To preview a new promotion code, create a renewal order and quote it by order_id."),
+        .describe("Preview renewing these subscriptions, each at most once; each entry is a separate renewal order. To preview a promotion code, create a renewal order and quote it by order_id."),
     cancellation: QuoteCancellation.optional(),
     promotion_code: zod.string().min(1).max(quoteRequestPromotionCodeMax).optional(),
     refund: OrderRefundQuoteInput.optional(),
 })
-    .describe('"Quote exactly one target: proposed items, an existing order, renewals, a cancellation or an order\nrefund. All targets use the specified billing account. Nothing is saved, charged, reserved or\ncanceled. Promotion codes apply only to a purchase basket or an existing order. An invalid\ncombination returns BILLING_PURCHASE_INVALID with the offending field."');
+    .describe("Quote exactly one target for the billing account: proposed items, an existing order, renewals, a cancellation or an order refund. Promotion codes apply only to proposed items or an existing order. An invalid combination fails with `BILLING_PURCHASE_INVALID` and the field.");

package/dist/canopy/v1/generated/validators/quotedDiscount.zod.js

@@ -43,4 +43,4 @@ export const QuotedDiscount = zod
         .nullable()
         .describe("Code text for a promotion_code discount; null for an account_discount."),
 })
-    .describe("The discount selected for this calculation. Its presence in a quote does not apply it or\nreserve a redemption. Discount amounts are reported on the quote and its lines.");
+    .describe("The discount selected for this calculation, not applied and not reserved. Amounts are on the quote and its lines.");

package/dist/canopy/v1/generated/validators/rate.zod.d.ts

@@ -43,6 +43,17 @@ export declare const Rate: zod.ZodObject<{
         per_unit: "per_unit";
         tiered: "tiered";
     }>;
+    usage_type: zod.ZodEnum<{
+        licensed: "licensed";
+        metered: "metered";
+    }>;
+    interval: zod.ZodEnum<{
+        none: "none";
+        day: "day";
+        month: "month";
+        year: "year";
+    }>;
+    interval_count: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
     tiers_mode: zod.ZodEnum<{
         none: "none";
         graduated: "graduated";

package/dist/canopy/v1/generated/validators/rate.zod.js

@@ -31,18 +31,26 @@
  * OpenAPI spec version: 1.0.0
  */
 import * as zod from "zod";
+import { BillingScheme } from "./billingScheme.zod.js";
 import { Money } from "./money.zod.js";
 import { ObjectIdentity } from "./objectIdentity.zod.js";
 import { Tier } from "./tier.zod.js";
+import { UsageType } from "./usageType.zod.js";
 export const Rate = zod.strictObject({
     meter: ObjectIdentity,
-    unit: zod.string().optional().describe("The unit readings arrive in, such as `core-second`."),
+    unit: zod
+        .string()
+        .optional()
+        .describe("The unit readings are reported in, such as `core-second`."),
     dimensions: zod
         .record(zod.string(), zod.string())
-        .describe("The attributes this rate applies to, such as region and machine type."),
-    billing_scheme: zod
-        .enum(["per_unit", "tiered"])
-        .describe("`per_unit` multiplies `unit_amount`; `tiered` walks the tiers as `tiers_mode` says."),
+        .describe("The dimension values this rate applies to, such as region and machine type."),
+    billing_scheme: BillingScheme,
+    usage_type: UsageType.describe("`metered` prices usage; `licensed` prices holding a quantity for one period."),
+    interval: zod
+        .enum(["none", "day", "month", "year"])
+        .describe("Licensed rates only, the period the amount buys; `none` for metered rates."),
+    interval_count: zod.int().nullish(),
     tiers_mode: zod
         .enum(["none", "graduated", "volume"])
         .describe("`graduated` charges each band at its own rate; `volume` charges everything at the rate of the band the total lands in. `none` for a `per_unit` rate."),
@@ -51,7 +59,7 @@ export const Rate = zod.strictObject({
     unit_quantity: zod
         .string()
         .optional()
-        .describe('How many measured units one amount covers. An hourly rate on a per-second meter is\n`"3600"`.'),
+        .describe('How many measured units one amount covers; an hourly rate on a per-second meter is `"3600"`.'),
     currency: zod.string(),
     effective_from: zod.iso.datetime({ offset: true }),
     effective_to: zod.iso.datetime({ offset: true }).nullish(),

package/dist/canopy/v1/generated/validators/rateList.zod.d.ts

@@ -44,6 +44,17 @@ export declare const RateList: zod.ZodObject<{
             per_unit: "per_unit";
             tiered: "tiered";
         }>;
+        usage_type: zod.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
+        }>;
+        interval: zod.ZodEnum<{
+            none: "none";
+            day: "day";
+            month: "month";
+            year: "year";
+        }>;
+        interval_count: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
         tiers_mode: zod.ZodEnum<{
             none: "none";
             graduated: "graduated";

package/dist/canopy/v1/generated/validators/reasoningCapabilities.zod.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const reasoningCapabilitiesBudgetTokensMinMin = 0;
+export declare const reasoningCapabilitiesBudgetTokensMaxMin = 0;
+export declare const ReasoningCapabilities: zod.ZodObject<{
+    supported: zod.ZodBoolean;
+    effort_levels: zod.ZodNullable<zod.ZodArray<zod.ZodString>>;
+    default_effort: zod.ZodNullable<zod.ZodString>;
+    modes: zod.ZodNullable<zod.ZodArray<zod.ZodString>>;
+    budget_tokens: zod.ZodNullable<zod.ZodObject<{
+        min: zod.ZodInt;
+        max: zod.ZodInt;
+    }, zod.z.core.$strict>>;
+    summary: zod.ZodNullable<zod.ZodArray<zod.ZodString>>;
+}, zod.z.core.$strict>;
+export type ReasoningCapabilities = zod.input<typeof ReasoningCapabilities>;
+export type ReasoningCapabilitiesOutput = zod.output<typeof ReasoningCapabilities>;

package/dist/canopy/v1/generated/validators/reasoningCapabilities.zod.js

@@ -0,0 +1,51 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const reasoningCapabilitiesBudgetTokensMinMin = 0;
+export const reasoningCapabilitiesBudgetTokensMaxMin = 0;
+export const ReasoningCapabilities = zod.strictObject({
+    supported: zod.boolean(),
+    effort_levels: zod
+        .array(zod.string())
+        .nullable()
+        .describe("Null means unknown; an empty array means effort is not configurable."),
+    default_effort: zod.string().nullable(),
+    modes: zod.array(zod.string()).nullable(),
+    budget_tokens: zod
+        .strictObject({
+        min: zod.int().min(reasoningCapabilitiesBudgetTokensMinMin),
+        max: zod.int().min(reasoningCapabilitiesBudgetTokensMaxMin),
+    })
+        .nullable(),
+    summary: zod.array(zod.string()).nullable(),
+});

package/dist/canopy/v1/generated/validators/reasoningDiagnostics.zod.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const ReasoningDiagnostics: zod.ZodObject<{
+    requested: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+    effective: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+    translation: zod.ZodOptional<zod.ZodEnum<{
+        translate: "translate";
+        passthrough: "passthrough";
+        strip: "strip";
+    }>>;
+}, zod.z.core.$strict>;
+export type ReasoningDiagnostics = zod.input<typeof ReasoningDiagnostics>;
+export type ReasoningDiagnosticsOutput = zod.output<typeof ReasoningDiagnostics>;

package/dist/canopy/v1/generated/validators/reasoningDiagnostics.zod.js

@@ -0,0 +1,38 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const ReasoningDiagnostics = zod.strictObject({
+    requested: zod.record(zod.string(), zod.unknown()),
+    effective: zod.record(zod.string(), zod.unknown()).optional(),
+    translation: zod.enum(["translate", "passthrough", "strip"]).optional(),
+});

package/dist/canopy/v1/generated/validators/refund.zod.js

@@ -39,14 +39,14 @@ export const Refund = zod.strictObject({
     cancellation_item_id: zod.uuid().optional(),
     transactions: zod
         .array(Transaction)
-        .describe("Original funds-return split and each result. Unknown gateway results remain pending."),
+        .describe("The refund split by original payment source, with each result. Unknown gateway results stay pending."),
     id: zod.uuid(),
     billing_account_id: zod.int().optional(),
     invoice_id: zod.uuid().nullish(),
     order_id: zod
         .uuid()
         .nullish()
-        .describe("The order the refund belongs to: the order that caused it, such as a downgrade, otherwise\nthe order of the refunded invoice. Null for refunds of top-ups and of usage invoices."),
+        .describe("The order the refund belongs to: the order that caused it, such as a downgrade, otherwise the order of the refunded invoice. Null for refunds of top-ups and usage invoices."),
     amount: Money.describe("The whole refund. Equals balance_amount plus credit_amount plus gateway_amount."),
     balance_amount: Money.describe("The part returned to the account balance."),
     credit_amount: Money.describe("The part restored to the credit grants that paid for it."),
@@ -56,7 +56,7 @@ export const Refund = zod.strictObject({
     destination: zod
         .enum(["balance", "gateway"])
         .optional()
-        .describe("Use balance_amount, credit_amount and gateway_amount, which also show a refund split between several destinations."),
+        .describe("Use balance_amount, credit_amount and gateway_amount, which also show a refund split between destinations."),
     status: zod
         .enum(["pending", "processing", "succeeded", "failed"])
         .describe("Summary of the parts in `transactions`.\n\n- `pending`: nothing has been returned yet, and at least one part is in progress.\n- `processing`: some parts have been returned, and at least one is still in progress.\n- `succeeded`: every part has been returned.\n- `failed`: no part is in progress and at least one has failed. What was returned is in\n  settled_amount.\n\nReturns to the balance and to credit grants complete shortly after the refund is made; a\nreturn to a payment method completes when the gateway confirms it."),

package/dist/canopy/v1/generated/validators/refundPolicy.zod.js

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const RefundPolicy = zod
     .enum(["none", "prorated"])
-    .describe("none refunds nothing. prorated refunds the amount paid for the current period minus the value of\nthe time used, never below zero and never more than what remains unrefunded. The time used runs\nfrom the period start to the effective cancellation time and is valued at the plan's\nshorter-period prices in the same currency, frozen at purchase as the order item's\nrefund_monthly_amount and refund_hourly_amount: each full calendar month at the one-month prepaid\nprice, the remainder at the postpaid hourly price or, without one, at the one-month price by the\nsecond. When the plan has no prepaid period shorter than the one bought, the time used is valued\nat the price paid, pro rata by the second. Discounts are not refunded, as they were never paid,\nand setup fees are excluded. The refunded part returns to the payment sources it came from. Tax\npaid is refunded in the same proportion as the amount it was paid on.");
+    .describe("`none` refunds nothing. `prorated` refunds the amount paid for the current period minus the value of the time used, never below zero or above what remains unrefunded. Time used runs from the period start to the effective cancellation and is valued at prices frozen on the order item: each full calendar month at `refund_monthly_amount`, the rest at `refund_hourly_amount` or, without it, at the monthly price by the second. When the plan has no licensed period shorter than the one bought, time used is valued pro rata at the price paid. Discounts and setup fees are not refunded. Refunds return to the original payment sources, with tax refunded in proportion.");

package/dist/canopy/v1/generated/validators/refundReason.zod.js

@@ -45,4 +45,4 @@ export const RefundReason = zod
     "payment_not_applied",
     "operator",
 ])
-    .describe("Why the refund was made. Clients map the code to their own wording. More codes may be added;\ntreat an unknown code as a refund without a stated reason.\n\n- `provisioning_failed`: the purchase could not be delivered.\n- `order_expired`: the order expired after part of it had been paid.\n- `order_canceled`: the account holder canceled the order after part of it had been paid.\n- `change_canceled`: a scheduled change was withdrawn after part of it had been paid.\n- `change_expired`: a scheduled change could not take effect before its time passed.\n- `subscription_canceled`: the subscription was canceled and its unused value returned under\n  its refund terms.\n- `future_period_canceled`: a renewal that had not started yet was withdrawn.\n- `downgrade_difference`: after a downgrade, the remaining value of what was paid, valued as refund\n  policy `prorated` describes, minus the new configuration's cost for the remaining time at the\n  change item's `refund_monthly_amount` and `refund_hourly_amount`. Nothing is refunded when that is\n  zero or less.\n- `usage_true_up`: usage priced again over the whole month cost less than was charged.\n- `payment_not_applied`: a payment arrived after its invoice could no longer be paid.\n- `operator`: made by the platform operator.");
+    .describe("Why the refund was made. New codes may be added; treat an unknown code as unspecified.\n\n- `provisioning_failed`: the purchase could not be delivered.\n- `order_expired`: the order expired after part of it was paid.\n- `order_canceled`: the order was canceled after part of it was paid.\n- `change_canceled`: a scheduled change was withdrawn after part of it was paid.\n- `change_expired`: a scheduled change could not take effect in time.\n- `subscription_canceled`: the unused value of a canceled subscription, under its refund terms.\n- `future_period_canceled`: a renewal that had not started was withdrawn.\n- `downgrade_difference`: after a downgrade, the remaining paid value, valued as refund policy `prorated`\n  describes, minus the new configuration's cost for the remaining time at the change item's\n  `refund_monthly_amount` and `refund_hourly_amount`.\n- `usage_true_up`: usage priced over the whole month cost less than was charged.\n- `payment_not_applied`: a payment arrived after its invoice could no longer be paid.\n- `operator`: made by the platform operator.");

package/dist/canopy/v1/generated/validators/renewRequest.zod.js

@@ -38,12 +38,12 @@ export const renewRequestUseCreditsDefault = true;
 export const RenewRequest = zod.strictObject({
     order_id: zod
         .uuid()
-        .describe("Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result."),
+        .describe("The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome."),
     periods: zod
         .int()
         .min(1)
         .default(renewRequestPeriodsDefault)
-        .describe("How many further periods to buy, each at the price this item already bills at.\n\nBuying twelve monthly periods is not the same as buying one yearly term: a longer\nterm is usually sold at a lower price, and that price is only reached by naming the\ninterval. Use `interval_count` and `interval` for that."),
+        .describe("How many further periods to buy, each at the price the subscription already renews at. To buy a longer term at its own price, give `interval` and `interval_count` instead."),
     interval_count: zod
         .int()
         .min(1)

package/dist/canopy/v1/generated/validators/renewalOrderRequest.zod.js

@@ -37,7 +37,7 @@ export const RenewalOrderRequest = zod
     .strictObject({
     order_id: zod
         .uuid()
-        .describe("Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result."),
+        .describe("The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome."),
     periods: zod
         .int()
         .min(1)
@@ -47,4 +47,4 @@ export const RenewalOrderRequest = zod
     interval: zod.enum(["day", "month", "year"]).optional().describe("As in renewing."),
     termination_policy: TerminationPolicy.optional().describe("As in renewing."),
 })
-    .describe("The periods and price of the renewal, chosen as in renewing.");
+    .describe("The renewal's periods and price, chosen as in renewing.");

package/dist/canopy/v1/generated/validators/renewalPrice.zod.js

@@ -44,5 +44,5 @@ export const RenewalPrice = zod.strictObject({
     currency: zod.string().optional(),
     current: zod
         .boolean()
-        .describe("The term this item already bills at. Renewing for it uses the price bought\noriginally, so a later price change does not affect it."),
+        .describe("The term the subscription renews at now; renewing for it keeps the agreed price."),
 });

package/dist/canopy/v1/generated/validators/requestResource.zod.d.ts

@@ -60,6 +60,15 @@ export declare const RequestResource: zod.ZodObject<{
         upstream: "upstream";
         estimated: "estimated";
     }>;
+    reasoning: zod.ZodUnion<readonly [zod.ZodObject<{
+        requested: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+        effective: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+        translation: zod.ZodOptional<zod.ZodEnum<{
+            translate: "translate";
+            passthrough: "passthrough";
+            strip: "strip";
+        }>>;
+    }, zod.z.core.$strict>, zod.ZodNull]>;
 }, zod.z.core.$strict>;
 export type RequestResource = zod.input<typeof RequestResource>;
 export type RequestResourceOutput = zod.output<typeof RequestResource>;

package/dist/canopy/v1/generated/validators/requestResource.zod.js

@@ -31,6 +31,7 @@
  * OpenAPI spec version: 1.0.0
  */
 import * as zod from "zod";
+import { ReasoningDiagnostics } from "./reasoningDiagnostics.zod.js";
 export const RequestResource = zod.strictObject({
     api_key_id: zod
         .uuid()
@@ -61,4 +62,5 @@ export const RequestResource = zod.strictObject({
     usage_source: zod
         .enum(["none", "upstream", "estimated"])
         .describe("upstream means the figures were reported by the provider; estimated means they were derived from the character classes of the payload"),
+    reasoning: zod.union([ReasoningDiagnostics, zod.null()]),
 });

package/dist/canopy/v1/generated/validators/responseCreate.zod.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const responseCreateStoreDefault = false;
+export declare const responseCreateStreamDefault = false;
+export declare const ResponseCreate: zod.ZodObject<{
+    model: zod.ZodOptional<zod.ZodString>;
+    input: zod.ZodOptional<zod.ZodUnknown>;
+    instructions: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    store: zod.ZodDefault<zod.ZodBoolean>;
+    stream: zod.ZodDefault<zod.ZodBoolean>;
+    previous_response_id: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    reasoning: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+    tools: zod.ZodOptional<zod.ZodArray<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>>;
+    max_output_tokens: zod.ZodOptional<zod.ZodInt>;
+}, zod.z.core.$strict>;
+export type ResponseCreate = zod.input<typeof ResponseCreate>;
+export type ResponseCreateOutput = zod.output<typeof ResponseCreate>;

package/dist/canopy/v1/generated/validators/responseCreate.zod.js

@@ -0,0 +1,48 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const responseCreateStoreDefault = false;
+export const responseCreateStreamDefault = false;
+export const ResponseCreate = zod
+    .strictObject({
+    model: zod.string().optional(),
+    input: zod.unknown().optional(),
+    instructions: zod.string().nullish(),
+    store: zod.boolean().default(responseCreateStoreDefault),
+    stream: zod.boolean().default(responseCreateStreamDefault),
+    previous_response_id: zod.string().nullish(),
+    reasoning: zod.record(zod.string(), zod.unknown()).optional(),
+    tools: zod.array(zod.record(zod.string(), zod.unknown())).optional(),
+    max_output_tokens: zod.int().min(1).optional(),
+})
+    .describe("Native Responses request. model may be omitted when continuing a project-owned stored response. store defaults to false. Only caller-executed function and custom tools are supported. background, conversation and WebSocket-only fields are rejected over HTTP.");

package/dist/canopy/v1/generated/validators/responseDeleted.zod.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const ResponseDeleted: zod.ZodObject<{
+    id: zod.ZodString;
+    object: zod.ZodString;
+    deleted: zod.ZodBoolean;
+}, zod.z.core.$strict>;
+export type ResponseDeleted = zod.input<typeof ResponseDeleted>;
+export type ResponseDeletedOutput = zod.output<typeof ResponseDeleted>;