@leaflow/sdk 0.0.0-dev.516.g28eeab9 → 0.0.0-dev.523.gcaeef48

package/dist/canopy/v1/generated/models.d.ts

@@ -637,6 +637,36 @@ export interface MediaUsage {
 export interface ModelListResponseBody {
     items: ModelResource[];
 }
+export type MediaUsageDetailsReferenceCounts = {
+    [key: string]: number;
+};
+/**
+ * Per-request media measurements. Omitted values are unknown, not zero.
+ * Reference counts are audit data, not an additional billable quantity.
+ * video_quantity is the exact decimal quantity for the existing video_seconds
+ * meter; video_seconds in the summary remains a rounded compatibility counter.
+ * No monetary price or refund is calculated by Canopy.
+ */
+export interface MediaUsageDetails {
+    /** @minimum 0 */
+    input_video_seconds?: number;
+    /** @minimum 0 */
+    output_video_seconds?: number;
+    /** @minimum 0 */
+    input_audio_seconds?: number;
+    /**
+     * Recorded input quantity for the input_images meter, independent of its Billing price. Absent when unmeasured or not separately metered.
+     * @pattern ^[0-9]+$
+     */
+    input_image_quantity?: string;
+    /** @minimum 0 */
+    input_images?: number;
+    /** @minimum 0 */
+    output_images?: number;
+    /** @pattern ^[0-9]+([.][0-9]+)?$ */
+    video_quantity?: string;
+    reference_counts?: MediaUsageDetailsReferenceCounts;
+}
 export type RequestResourceStatus = (typeof RequestResourceStatus)[keyof typeof RequestResourceStatus];
 export declare const RequestResourceStatus: {
     readonly in_flight: "in_flight";
@@ -716,6 +746,7 @@ export interface RequestResource {
     reasoning: ReasoningDiagnostics | null;
     /** Media quantities and their rate dimensions. Null for a token-only request. */
     media?: MediaUsage | null;
+    media_details?: MediaUsageDetails;
 }
 export interface CursorPageRequestResource {
     /** The items in this page */
@@ -987,6 +1018,120 @@ export interface CreateServiceResponseBody {
      */
     order_id: string | null;
 }
+export type VideoReferenceMediaType = (typeof VideoReferenceMediaType)[keyof typeof VideoReferenceMediaType];
+export declare const VideoReferenceMediaType: {
+    readonly first_frame: "first_frame";
+    readonly last_frame: "last_frame";
+    readonly reference_image: "reference_image";
+    readonly reference_video: "reference_video";
+    readonly reference_audio: "reference_audio";
+};
+/**
+ * A typed reference asset. Order is preserved, including order within each media type.
+ * Wan 3.0 accepts at most one first frame, one last frame, ten reference images,
+ * five reference videos and five reference audio clips. A last frame needs a first frame.
+ * First/last frames cannot be combined with reference_image, reference_video or reference_audio.
+ * Reference images, videos and audio may be combined. Other models can accept fewer roles.
+ * Images accept public HTTP(S) or base64 image data URLs. Video and audio accept public
+ * HTTP(S) URLs only. Wan 3.0 limits reference videos and audio to 1-15 seconds each and
+ * 15 seconds total per media type; input video plus output duration must not exceed 30 seconds.
+ * The upstream validates remote asset size, format and duration. Canopy does not fetch them.
+ */
+export interface VideoReferenceMedia {
+    type: VideoReferenceMediaType;
+    /** @minLength 1 */
+    url: string;
+}
+/**
+ * Provide a prompt, reference media, or both. Extra fields depend on the selected model and adapter.
+ */
+export interface VideoCreateRequest {
+    /** @minLength 1 */
+    model: string;
+    prompt?: string;
+    /** @minimum 1 */
+    seconds?: number;
+    size?: string;
+    resolution?: string;
+    /**
+     * Backward-compatible first-frame image URL. May be combined with a last_frame, not another first_frame.
+     * @minLength 1
+     */
+    input_reference?: string;
+    /**
+     * @minItems 1
+     * @maxItems 20
+     */
+    reference_media?: VideoReferenceMedia[];
+    /** Whether the output has audio; separate from a reference_audio input. */
+    audio?: boolean;
+    prompt_extend?: boolean;
+    watermark?: boolean;
+    seed?: number;
+    negative_prompt?: string;
+    [key: string]: unknown;
+}
+/**
+ * Provider measurements on a task; only completed tasks are settled.
+ */
+export interface VideoUsage {
+    /**
+     * Output duration, kept for compatibility.
+     * @minimum 0
+     */
+    seconds?: number;
+    resolution?: string;
+    /** @minimum 0 */
+    input_seconds?: number;
+    /** @minimum 0 */
+    output_seconds?: number;
+    /**
+     * Total measured input and output video duration, not a monetary quote.
+     * @minimum 0
+     */
+    billable_seconds?: number;
+    [key: string]: unknown;
+}
+export type VideoTaskStatus = (typeof VideoTaskStatus)[keyof typeof VideoTaskStatus];
+export declare const VideoTaskStatus: {
+    readonly queued: "queued";
+    readonly in_progress: "in_progress";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+export type VideoTaskError = {
+    code?: string;
+    message?: string;
+    [key: string]: unknown;
+};
+export interface VideoTask {
+    id: string;
+    object: string;
+    status: VideoTaskStatus;
+    model?: string;
+    usage?: VideoUsage;
+    /** Output duration, not the duration of input references. */
+    seconds?: string;
+    size?: string;
+    created_at?: number;
+    completed_at?: number;
+    expires_at?: number;
+    progress?: number;
+    error?: VideoTaskError;
+    [key: string]: unknown;
+}
+/**
+ * A request body in the endpoint's own protocol. Canopy reads only the model name and forwards the rest unchanged.
+ */
+export interface NativeRequest {
+    [key: string]: unknown;
+}
+/**
+ * A response body in the endpoint's own protocol, as the upstream returned it.
+ */
+export interface NativeResponse {
+    [key: string]: unknown;
+}
 export type ResponseCreateReasoning = {
     [key: string]: unknown;
 };
@@ -1019,18 +1164,6 @@ export interface ResponseDeleted {
     object: string;
     deleted: boolean;
 }
-/**
- * A request body in the endpoint's own protocol. Canopy reads only the model name and forwards the rest unchanged.
- */
-export interface NativeRequest {
-    [key: string]: unknown;
-}
-/**
- * A response body in the endpoint's own protocol, as the upstream returned it.
- */
-export interface NativeResponse {
-    [key: string]: unknown;
-}
 /**
  * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
  */
@@ -1055,6 +1188,9 @@ export interface CursorPagination {
  * The request conflicts with the current state of the service. The codes are described where they apply.
  */
 export type ConflictResponse = Error;
+export type GetVideoContentHeaders = {
+    Range?: string;
+};
 export type StreamGenerateContentParams = {
     alt?: StreamGenerateContentAlt;
 };

package/dist/canopy/v1/generated/models.js

@@ -99,6 +99,19 @@ export const CheckoutMode = {
     automatic: "automatic",
     deferred: "deferred",
 };
+export const VideoReferenceMediaType = {
+    first_frame: "first_frame",
+    last_frame: "last_frame",
+    reference_image: "reference_image",
+    reference_video: "reference_video",
+    reference_audio: "reference_audio",
+};
+export const VideoTaskStatus = {
+    queued: "queued",
+    in_progress: "in_progress",
+    completed: "completed",
+    failed: "failed",
+};
 export const StreamGenerateContentAlt = {
     sse: "sse",
 };

package/dist/canopy/v1/generated/schemas.zod.d.ts

@@ -39,6 +39,55 @@
  * OpenAPI spec version: 1.0.0
  */
 import * as zod from "zod";
+/**
+ * Create an asynchronous video task in the verified project. Model and upstream support
+ * determine the accepted duration, resolution and references. Poll the returned task id.
+ * `reference_media` is a Canopy extension for ordered, typed image, video and audio URLs.
+ * Existing `input_reference` remains a first frame.
+ * The runtime also accepts OpenAI multipart uploads; send reference_media as a JSON text field.
+ * No remote reference is downloaded or retained by Canopy during request preparation.
+ * @summary Create a video
+ */
+export declare const CreateVideoBody: zod.ZodObject<{
+    model: zod.ZodString;
+    prompt: zod.ZodOptional<zod.ZodString>;
+    seconds: zod.ZodOptional<zod.ZodInt>;
+    size: zod.ZodOptional<zod.ZodString>;
+    resolution: zod.ZodOptional<zod.ZodString>;
+    input_reference: zod.ZodOptional<zod.ZodString>;
+    reference_media: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        type: zod.ZodEnum<{
+            first_frame: "first_frame";
+            last_frame: "last_frame";
+            reference_image: "reference_image";
+            reference_video: "reference_video";
+            reference_audio: "reference_audio";
+        }>;
+        url: zod.ZodString;
+    }, zod.z.core.$strict>>>;
+    audio: zod.ZodOptional<zod.ZodBoolean>;
+    prompt_extend: zod.ZodOptional<zod.ZodBoolean>;
+    watermark: zod.ZodOptional<zod.ZodBoolean>;
+    seed: zod.ZodOptional<zod.ZodInt>;
+    negative_prompt: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+/**
+ * Read an existing task owned by the verified project; does not create another video.
+ * @summary Get a video task
+ */
+export declare const GetVideoParams: zod.ZodObject<{
+    video: zod.ZodString;
+}, zod.z.core.$strict>;
+/**
+ * Stream a completed video owned by the verified project. Supports HTTP Range.
+ * @summary Get generated video content
+ */
+export declare const GetVideoContentParams: zod.ZodObject<{
+    video: zod.ZodString;
+}, zod.z.core.$strict>;
+export declare const GetVideoContentHeader: zod.ZodObject<{
+    Range: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
 /**
  * Supports JSON, SSE and native upstream response storage. Stored continuation is restricted to the current project and original provider credential. WebSocket clients connect with GET /v1/responses and send response.create events; one response may be active on a connection at a time. The connection stays on its initial model and provider credential.
  * @summary Create a model response

package/dist/canopy/v1/generated/schemas.zod.js

@@ -46,6 +46,34 @@ import { EmbeddingRequest } from "./validators/embeddingRequest.zod.js";
 import { NativeRequest } from "./validators/nativeRequest.zod.js";
 import { ResponseCreate } from "./validators/responseCreate.zod.js";
 import { UpdateAPIKeyRequestBody } from "./validators/updateAPIKeyRequestBody.zod.js";
+import { VideoCreateRequest } from "./validators/videoCreateRequest.zod.js";
+/**
+ * Create an asynchronous video task in the verified project. Model and upstream support
+ * determine the accepted duration, resolution and references. Poll the returned task id.
+ * `reference_media` is a Canopy extension for ordered, typed image, video and audio URLs.
+ * Existing `input_reference` remains a first frame.
+ * The runtime also accepts OpenAI multipart uploads; send reference_media as a JSON text field.
+ * No remote reference is downloaded or retained by Canopy during request preparation.
+ * @summary Create a video
+ */
+export const CreateVideoBody = VideoCreateRequest;
+/**
+ * Read an existing task owned by the verified project; does not create another video.
+ * @summary Get a video task
+ */
+export const GetVideoParams = zod.strictObject({
+    video: zod.string().min(1),
+});
+/**
+ * Stream a completed video owned by the verified project. Supports HTTP Range.
+ * @summary Get generated video content
+ */
+export const GetVideoContentParams = zod.strictObject({
+    video: zod.string().min(1),
+});
+export const GetVideoContentHeader = zod.strictObject({
+    Range: zod.string().optional(),
+});
 /**
  * Supports JSON, SSE and native upstream response storage. Stored continuation is restricted to the current project and original provider credential. WebSocket clients connect with GET /v1/responses and send response.create events; one response may be active on a connection at a time. The connection stays on its initial model and provider credential.
  * @summary Create a model response

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

@@ -83,6 +83,16 @@ export declare const CursorPageRequestResource: zod.ZodObject<{
             quality: zod.ZodNullable<zod.ZodString>;
             resolution: zod.ZodNullable<zod.ZodString>;
         }, zod.z.core.$strict>, zod.ZodNull]>>;
+        media_details: zod.ZodOptional<zod.ZodObject<{
+            input_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+            output_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+            input_audio_seconds: zod.ZodOptional<zod.ZodNumber>;
+            input_image_quantity: zod.ZodOptional<zod.ZodString>;
+            input_images: zod.ZodOptional<zod.ZodInt>;
+            output_images: zod.ZodOptional<zod.ZodInt>;
+            video_quantity: zod.ZodOptional<zod.ZodString>;
+            reference_counts: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodInt>>;
+        }, zod.z.core.$strict>>;
     }, zod.z.core.$strict>>;
     next_cursor: zod.ZodString;
 }, zod.z.core.$strict>;

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

@@ -0,0 +1,46 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/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 serves the same endpoints.
+ *
+ * ## 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, or 400 days for the usage timeline. `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 Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const GetVideoContentHeaders: zod.ZodObject<{
+    Range: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type GetVideoContentHeaders = zod.input<typeof GetVideoContentHeaders>;
+export type GetVideoContentHeadersOutput = zod.output<typeof GetVideoContentHeaders>;

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

@@ -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.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/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 serves the same endpoints.
+ *
+ * ## 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, or 400 days for the usage timeline. `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 Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const GetVideoContentHeaders = zod.strictObject({
+    Range: zod.string().optional(),
+});

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

@@ -0,0 +1,61 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/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 serves the same endpoints.
+ *
+ * ## 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, or 400 days for the usage timeline. `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 Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const mediaUsageDetailsInputVideoSecondsMin = 0;
+export declare const mediaUsageDetailsOutputVideoSecondsMin = 0;
+export declare const mediaUsageDetailsInputAudioSecondsMin = 0;
+export declare const mediaUsageDetailsInputImageQuantityRegExp: RegExp;
+export declare const mediaUsageDetailsInputImagesMin = 0;
+export declare const mediaUsageDetailsOutputImagesMin = 0;
+export declare const mediaUsageDetailsVideoQuantityRegExp: RegExp;
+export declare const mediaUsageDetailsReferenceCountsMinOne = 0;
+export declare const MediaUsageDetails: zod.ZodObject<{
+    input_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+    output_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+    input_audio_seconds: zod.ZodOptional<zod.ZodNumber>;
+    input_image_quantity: zod.ZodOptional<zod.ZodString>;
+    input_images: zod.ZodOptional<zod.ZodInt>;
+    output_images: zod.ZodOptional<zod.ZodInt>;
+    video_quantity: zod.ZodOptional<zod.ZodString>;
+    reference_counts: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodInt>>;
+}, zod.z.core.$strict>;
+export type MediaUsageDetails = zod.input<typeof MediaUsageDetails>;
+export type MediaUsageDetailsOutput = zod.output<typeof MediaUsageDetails>;

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

@@ -0,0 +1,67 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/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 serves the same endpoints.
+ *
+ * ## 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, or 400 days for the usage timeline. `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 Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const mediaUsageDetailsInputVideoSecondsMin = 0;
+export const mediaUsageDetailsOutputVideoSecondsMin = 0;
+export const mediaUsageDetailsInputAudioSecondsMin = 0;
+export const mediaUsageDetailsInputImageQuantityRegExp = new RegExp("^[0-9]+$");
+export const mediaUsageDetailsInputImagesMin = 0;
+export const mediaUsageDetailsOutputImagesMin = 0;
+export const mediaUsageDetailsVideoQuantityRegExp = new RegExp("^[0-9]+([.][0-9]+)?$");
+export const mediaUsageDetailsReferenceCountsMinOne = 0;
+export const MediaUsageDetails = zod
+    .strictObject({
+    input_video_seconds: zod.number().min(mediaUsageDetailsInputVideoSecondsMin).optional(),
+    output_video_seconds: zod.number().min(mediaUsageDetailsOutputVideoSecondsMin).optional(),
+    input_audio_seconds: zod.number().min(mediaUsageDetailsInputAudioSecondsMin).optional(),
+    input_image_quantity: zod
+        .string()
+        .regex(mediaUsageDetailsInputImageQuantityRegExp)
+        .optional()
+        .describe("Recorded input quantity for the input_images meter, independent of its Billing price. Absent when unmeasured or not separately metered."),
+    input_images: zod.int().min(mediaUsageDetailsInputImagesMin).optional(),
+    output_images: zod.int().min(mediaUsageDetailsOutputImagesMin).optional(),
+    video_quantity: zod.string().regex(mediaUsageDetailsVideoQuantityRegExp).optional(),
+    reference_counts: zod
+        .record(zod.string(), zod.int().min(mediaUsageDetailsReferenceCountsMinOne))
+        .optional(),
+})
+    .describe("Per-request media measurements. Omitted values are unknown, not zero.\nReference counts are audit data, not an additional billable quantity.\nvideo_quantity is the exact decimal quantity for the existing video_seconds\nmeter; video_seconds in the summary remains a rounded compatibility counter.\nNo monetary price or refund is calculated by Canopy.");

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

@@ -83,6 +83,16 @@ export declare const RequestResource: zod.ZodObject<{
         quality: zod.ZodNullable<zod.ZodString>;
         resolution: zod.ZodNullable<zod.ZodString>;
     }, zod.z.core.$strict>, zod.ZodNull]>>;
+    media_details: zod.ZodOptional<zod.ZodObject<{
+        input_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+        output_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+        input_audio_seconds: zod.ZodOptional<zod.ZodNumber>;
+        input_image_quantity: zod.ZodOptional<zod.ZodString>;
+        input_images: zod.ZodOptional<zod.ZodInt>;
+        output_images: zod.ZodOptional<zod.ZodInt>;
+        video_quantity: zod.ZodOptional<zod.ZodString>;
+        reference_counts: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodInt>>;
+    }, zod.z.core.$strict>>;
 }, 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

@@ -40,6 +40,7 @@
  */
 import * as zod from "zod";
 import { MediaUsage } from "./mediaUsage.zod.js";
+import { MediaUsageDetails } from "./mediaUsageDetails.zod.js";
 import { ReasoningDiagnostics } from "./reasoningDiagnostics.zod.js";
 export const requestResourceSourceMax = 64;
 export const RequestResource = zod.strictObject({
@@ -101,4 +102,5 @@ export const RequestResource = zod.strictObject({
         .union([MediaUsage, zod.null()])
         .optional()
         .describe("Media quantities and their rate dimensions. Null for a token-only request."),
+    media_details: MediaUsageDetails.optional(),
 });

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

@@ -0,0 +1,67 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/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 serves the same endpoints.
+ *
+ * ## 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, or 400 days for the usage timeline. `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 Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const videoCreateRequestReferenceMediaMax = 20;
+export declare const VideoCreateRequest: zod.ZodObject<{
+    model: zod.ZodString;
+    prompt: zod.ZodOptional<zod.ZodString>;
+    seconds: zod.ZodOptional<zod.ZodInt>;
+    size: zod.ZodOptional<zod.ZodString>;
+    resolution: zod.ZodOptional<zod.ZodString>;
+    input_reference: zod.ZodOptional<zod.ZodString>;
+    reference_media: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        type: zod.ZodEnum<{
+            first_frame: "first_frame";
+            last_frame: "last_frame";
+            reference_image: "reference_image";
+            reference_video: "reference_video";
+            reference_audio: "reference_audio";
+        }>;
+        url: zod.ZodString;
+    }, zod.z.core.$strict>>>;
+    audio: zod.ZodOptional<zod.ZodBoolean>;
+    prompt_extend: zod.ZodOptional<zod.ZodBoolean>;
+    watermark: zod.ZodOptional<zod.ZodBoolean>;
+    seed: zod.ZodOptional<zod.ZodInt>;
+    negative_prompt: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type VideoCreateRequest = zod.input<typeof VideoCreateRequest>;
+export type VideoCreateRequestOutput = zod.output<typeof VideoCreateRequest>;