@leaflow/sdk 0.141.0 → 0.142.0

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

@@ -30,13 +30,78 @@
  * - **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 type { APIKeyResource, APIKeyUsageListResponseBody, ChatCompletion, ChatCompletionRequest, ConflictResponse, CreateAPIKeyRequestBody, CreateServiceRequestBody, CreateServiceResponseBody, CursorPageRequestResource, EmbeddingRequest, EmbeddingResponse, Error, GetUsageSummaryParams, GetUsageTimelineParams, InferenceError, IssuedAPIKeyResource, LengthAwarePageAPIKeyResource, ListApiKeysParams, ListRequestsParams, ListUsageByApiKeyParams, ListUsageByModelParams, Model, ModelList, ModelListResponseBody, ModelResource, ModelUsageListResponseBody, Quote, RequestResource, ServiceResource, TotalsResource, UpdateAPIKeyRequestBody, UsageTimelineResponseBody } from "./models.js";
+import type { APIKeyResource, APIKeyUsageListResponseBody, ChatCompletion, ChatCompletionRequest, ConflictResponse, CreateAPIKeyRequestBody, CreateServiceRequestBody, CreateServiceResponseBody, CursorPageRequestResource, EmbeddingRequest, EmbeddingResponse, Error, GetUsageSummaryParams, GetUsageTimelineParams, InferenceError, IssuedAPIKeyResource, LengthAwarePageAPIKeyResource, ListApiKeysParams, ListRequestsParams, ListUsageByApiKeyParams, ListUsageByModelParams, Model, ModelList, ModelListResponseBody, ModelResource, ModelUsageListResponseBody, Quote, RequestResource, ResponseCreate, ResponseDeleted, ResponseResource, ServiceResource, TotalsResource, UpdateAPIKeyRequestBody, UsageTimelineResponseBody } from "./models.js";
 export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
 export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
 export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
 export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
 export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
 export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type createResponseResponse200ApplicationJson = {
+    data: ResponseResource;
+    status: 200;
+};
+export type createResponseResponse200TextEventStream = {
+    data: Blob;
+    status: 200;
+};
+export type createResponseResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createResponseResponseSuccess = (createResponseResponse200ApplicationJson | createResponseResponse200TextEventStream) & {
+    headers: Headers;
+};
+export type createResponseResponseError = createResponseResponseDefault & {
+    headers: Headers;
+};
+export type createResponseResponse = createResponseResponseSuccess | createResponseResponseError;
+export declare const getCreateResponseUrl: () => string;
+/**
+ * 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
+ */
+export declare const createResponse: (responseCreate: ResponseCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createResponseResponse>;
+export type getResponseResponse200 = {
+    data: ResponseResource;
+    status: 200;
+};
+export type getResponseResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getResponseResponseSuccess = getResponseResponse200 & {
+    headers: Headers;
+};
+export type getResponseResponseError = getResponseResponseDefault & {
+    headers: Headers;
+};
+export type getResponseResponse = getResponseResponseSuccess | getResponseResponseError;
+export declare const getGetResponseUrl: (response: string) => string;
+/**
+ * @summary Get a stored response
+ */
+export declare const getResponse: (response: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getResponseResponse>;
+export type deleteResponseResponse200 = {
+    data: ResponseDeleted;
+    status: 200;
+};
+export type deleteResponseResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type deleteResponseResponseSuccess = deleteResponseResponse200 & {
+    headers: Headers;
+};
+export type deleteResponseResponseError = deleteResponseResponseDefault & {
+    headers: Headers;
+};
+export type deleteResponseResponse = deleteResponseResponseSuccess | deleteResponseResponseError;
+export declare const getDeleteResponseUrl: (response: string) => string;
+/**
+ * @summary Delete a stored response
+ */
+export declare const deleteResponse: (response: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteResponseResponse>;
 export type createChatCompletionResponse200ApplicationJson = {
     data: ChatCompletion;
     status: 200;

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

@@ -1,3 +1,70 @@
+export const getCreateResponseUrl = () => {
+    return `https://canopy.leaflow.cloud/v1/responses`;
+};
+/**
+ * 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
+ */
+export const createResponse = async (responseCreate, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateResponseUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(responseCreate),
+    });
+    const body = [204, 205, 304].includes(res.status)
+        ? null
+        : res.headers.get("content-type")?.includes("application/json")
+            ? JSON.parse(await res.text())
+            : await res.blob();
+    const data = body;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetResponseUrl = (response) => {
+    return `https://canopy.leaflow.cloud/v1/responses/${encodeURIComponent(String(response))}`;
+};
+/**
+ * @summary Get a stored response
+ */
+export const getResponse = async (response, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetResponseUrl(response), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteResponseUrl = (response) => {
+    return `https://canopy.leaflow.cloud/v1/responses/${encodeURIComponent(String(response))}`;
+};
+/**
+ * @summary Delete a stored response
+ */
+export const deleteResponse = async (response, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteResponseUrl(response), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
 export const getCreateChatCompletionUrl = () => {
     return `https://canopy.leaflow.cloud/v1/chat/completions`;
 };

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

@@ -30,6 +30,23 @@
  * - **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
  */
+export type ReasoningDiagnosticsRequested = {
+    [key: string]: unknown;
+};
+export type ReasoningDiagnosticsEffective = {
+    [key: string]: unknown;
+};
+export type ReasoningDiagnosticsTranslation = (typeof ReasoningDiagnosticsTranslation)[keyof typeof ReasoningDiagnosticsTranslation];
+export declare const ReasoningDiagnosticsTranslation: {
+    readonly translate: "translate";
+    readonly passthrough: "passthrough";
+    readonly strip: "strip";
+};
+export interface ReasoningDiagnostics {
+    requested: ReasoningDiagnosticsRequested;
+    effective?: ReasoningDiagnosticsEffective;
+    translation?: ReasoningDiagnosticsTranslation;
+}
 export type ChatCompletionRequestMessagesItem = {
     [key: string]: unknown;
 };
@@ -68,6 +85,65 @@ export interface EmbeddingRequest {
 export interface EmbeddingResponse {
     [key: string]: unknown;
 }
+export type Modality = (typeof Modality)[keyof typeof Modality];
+export declare const Modality: {
+    readonly text: "text";
+    readonly image: "image";
+    readonly audio: "audio";
+    readonly video: "video";
+    readonly file: "file";
+    readonly embedding: "embedding";
+};
+/**
+ * @nullable
+ */
+export type ReasoningCapabilitiesBudgetTokens = {
+    /** @minimum 0 */
+    min: number;
+    /** @minimum 0 */
+    max: number;
+} | null;
+export interface ReasoningCapabilities {
+    supported: boolean;
+    /**
+     * Null means unknown; an empty array means effort is not configurable.
+     * @nullable
+     */
+    effort_levels: string[] | null;
+    /** @nullable */
+    default_effort: string | null;
+    /** @nullable */
+    modes: string[] | null;
+    /** @nullable */
+    budget_tokens: ReasoningCapabilitiesBudgetTokens;
+    /** @nullable */
+    summary: string[] | null;
+}
+export interface EndpointCapabilities {
+    /** @nullable */
+    function_calling: boolean | null;
+    /** @nullable */
+    structured_output: boolean | null;
+    reasoning: ReasoningCapabilities | null;
+}
+/**
+ * Verified capabilities keyed by API endpoint, for example /v1/chat/completions or /v1/responses. Missing keys and null values mean unknown. Current route availability is separate.
+ */
+export interface ModelCapabilities {
+    [key: string]: EndpointCapabilities;
+}
+export type ModelEndpoint = (typeof ModelEndpoint)[keyof typeof ModelEndpoint];
+export declare const ModelEndpoint: {
+    readonly "/v1/chat/completions": "/v1/chat/completions";
+    readonly "/v1/responses": "/v1/responses";
+    readonly "/v1/embeddings": "/v1/embeddings";
+    readonly "/v1/images/generations": "/v1/images/generations";
+    readonly "/v1/images/edits": "/v1/images/edits";
+    readonly "/v1/audio/transcriptions": "/v1/audio/transcriptions";
+    readonly "/v1/audio/translations": "/v1/audio/translations";
+    readonly "/v1/audio/speech": "/v1/audio/speech";
+    readonly "/v1/realtime": "/v1/realtime";
+};
 export interface Model {
     id: string;
     object: "model";
@@ -76,10 +152,22 @@ export interface Model {
     display_name: string;
     context_length: number;
     max_output_tokens: number;
-    supports_vision: boolean;
-    supports_tools: boolean;
-    supports_reasoning: boolean;
-    reasoning_tiers: string[];
+    /** The model developer; not the upstream provider or model family. */
+    developer: string;
+    description: string;
+    /**
+     * Accepted input modalities. Null means unknown.
+     * @nullable
+     */
+    input_modalities: Modality[] | null;
+    /**
+     * Produced output modalities. Image input does not imply image generation.
+     * @nullable
+     */
+    output_modalities: Modality[] | null;
+    capabilities: ModelCapabilities;
+    /** Explicitly supported API endpoints. Requests to any other endpoint are rejected before upstream admission. */
+    supported_endpoints: ModelEndpoint[];
 }
 export interface ModelList {
     object: "list";
@@ -290,12 +378,23 @@ export interface ModelResource {
     max_output_tokens: number;
     /** What requests to this model cost. Null when the project has no billing account. */
     pricing: ModelPricing | null;
-    /** The values accepted for `reasoning_effort`. Empty means it is not supported */
-    reasoning_tiers: string[];
     status: ModelResourceStatus;
-    supports_reasoning: boolean;
-    supports_tools: boolean;
-    supports_vision: boolean;
+    /** The model developer; not the upstream provider or model family. */
+    developer: string;
+    description: string;
+    /**
+     * Accepted input modalities. Null means unknown.
+     * @nullable
+     */
+    input_modalities: Modality[] | null;
+    /**
+     * Produced output modalities. Image input does not imply image generation.
+     * @nullable
+     */
+    output_modalities: Modality[] | null;
+    capabilities: ModelCapabilities;
+    /** Explicitly supported API endpoints. Requests to any other endpoint are rejected before upstream admission. */
+    supported_endpoints: ModelEndpoint[];
 }
 export interface ModelListResponseBody {
     items: ModelResource[];
@@ -348,6 +447,7 @@ export interface RequestResource {
     upstream_status: number;
     /** upstream means the figures were reported by the provider; estimated means they were derived from the character classes of the payload */
     usage_source: RequestResourceUsageSource;
+    reasoning: ReasoningDiagnostics | null;
 }
 export interface CursorPageRequestResource {
     /** The items in this page */
@@ -659,6 +759,38 @@ export interface Quote {
      */
     refundable_amount: Money | null;
 }
+export type ResponseCreateReasoning = {
+    [key: string]: unknown;
+};
+export type ResponseCreateToolsItem = {
+    [key: string]: unknown;
+};
+/**
+ * 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.
+ */
+export interface ResponseCreate {
+    model?: string;
+    input?: unknown;
+    /** @nullable */
+    instructions?: string | null;
+    store?: boolean;
+    stream?: boolean;
+    /** @nullable */
+    previous_response_id?: string | null;
+    reasoning?: ResponseCreateReasoning;
+    tools?: ResponseCreateToolsItem[];
+    /** @minimum 1 */
+    max_output_tokens?: number;
+    [key: string]: unknown;
+}
+export interface ResponseResource {
+    [key: string]: unknown;
+}
+export interface ResponseDeleted {
+    id: string;
+    object: string;
+    deleted: boolean;
+}
 /**
  * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
  */

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

@@ -1,7 +1,31 @@
+export const ReasoningDiagnosticsTranslation = {
+    translate: "translate",
+    passthrough: "passthrough",
+    strip: "strip",
+};
 export const EmbeddingRequestEncodingFormat = {
     float: "float",
     base64: "base64",
 };
+export const Modality = {
+    text: "text",
+    image: "image",
+    audio: "audio",
+    video: "video",
+    file: "file",
+    embedding: "embedding",
+};
+export const ModelEndpoint = {
+    "/v1/chat/completions": "/v1/chat/completions",
+    "/v1/responses": "/v1/responses",
+    "/v1/embeddings": "/v1/embeddings",
+    "/v1/images/generations": "/v1/images/generations",
+    "/v1/images/edits": "/v1/images/edits",
+    "/v1/audio/transcriptions": "/v1/audio/transcriptions",
+    "/v1/audio/translations": "/v1/audio/translations",
+    "/v1/audio/speech": "/v1/audio/speech",
+    "/v1/realtime": "/v1/realtime",
+};
 export const APIKeyResourceStatus = {
     active: "active",
     disabled: "disabled",

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

@@ -31,6 +31,33 @@
  * OpenAPI spec version: 1.0.0
  */
 import * as zod from "zod";
+/**
+ * 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
+ */
+export declare const CreateResponseBody: 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>;
+/**
+ * @summary Get a stored response
+ */
+export declare const GetResponseParams: zod.ZodObject<{
+    response: zod.ZodString;
+}, zod.z.core.$strict>;
+/**
+ * @summary Delete a stored response
+ */
+export declare const DeleteResponseParams: zod.ZodObject<{
+    response: zod.ZodString;
+}, zod.z.core.$strict>;
 /**
  * Authenticated project inference. Billing ownership comes only from the verified project token; no Canopy API key or project header is required.
  * @summary Create a chat completion

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

@@ -35,7 +35,25 @@ import { ChatCompletionRequest } from "./validators/chatCompletionRequest.zod.js
 import { CreateAPIKeyRequestBody } from "./validators/createAPIKeyRequestBody.zod.js";
 import { CreateServiceRequestBody } from "./validators/createServiceRequestBody.zod.js";
 import { EmbeddingRequest } from "./validators/embeddingRequest.zod.js";
+import { ResponseCreate } from "./validators/responseCreate.zod.js";
 import { UpdateAPIKeyRequestBody } from "./validators/updateAPIKeyRequestBody.zod.js";
+/**
+ * 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
+ */
+export const CreateResponseBody = ResponseCreate;
+/**
+ * @summary Get a stored response
+ */
+export const GetResponseParams = zod.strictObject({
+    response: zod.string(),
+});
+/**
+ * @summary Delete a stored response
+ */
+export const DeleteResponseParams = zod.strictObject({
+    response: zod.string(),
+});
 /**
  * Authenticated project inference. Billing ownership comes only from the verified project token; no Canopy API key or project header is required.
  * @summary Create a chat completion

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

@@ -61,6 +61,15 @@ export declare const CursorPageRequestResource: 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>>;
     next_cursor: zod.ZodString;
 }, zod.z.core.$strict>;

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

@@ -0,0 +1,50 @@
+/**
+ * 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 EndpointCapabilities: zod.ZodObject<{
+    function_calling: zod.ZodNullable<zod.ZodBoolean>;
+    structured_output: zod.ZodNullable<zod.ZodBoolean>;
+    reasoning: zod.ZodUnion<readonly [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>, zod.ZodNull]>;
+}, zod.z.core.$strict>;
+export type EndpointCapabilities = zod.input<typeof EndpointCapabilities>;
+export type EndpointCapabilitiesOutput = zod.output<typeof EndpointCapabilities>;

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

@@ -0,0 +1,39 @@
+/**
+ * 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";
+import { ReasoningCapabilities } from "./reasoningCapabilities.zod.js";
+export const EndpointCapabilities = zod.strictObject({
+    function_calling: zod.boolean().nullable(),
+    structured_output: zod.boolean().nullable(),
+    reasoning: zod.union([ReasoningCapabilities, zod.null()]),
+});

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

@@ -0,0 +1,43 @@
+/**
+ * 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 Modality: zod.ZodEnum<{
+    file: "file";
+    text: "text";
+    image: "image";
+    audio: "audio";
+    video: "video";
+    embedding: "embedding";
+}>;
+export type Modality = zod.input<typeof Modality>;
+export type ModalityOutput = zod.output<typeof Modality>;

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

@@ -0,0 +1,34 @@
+/**
+ * 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 Modality = zod.enum(["text", "image", "audio", "video", "file", "embedding"]);