@homeflare/distilled-litellm 0.2.0 → 0.4.0

package/src/services/containers.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as C from "@distilled.cloud/core/category";
@@ -506,9 +506,17 @@ export const HandlerMultipartUploadV1ContainersContainerIdFilesPostResponse =
       "HandlerMultipartUploadV1ContainersContainerIdFilesPostResponse",
   }) as any as S.Schema<HandlerMultipartUploadV1ContainersContainerIdFilesPostResponse>;
 
-export interface ListContainersContainersGetRequest {}
+export interface ListContainersContainersGetRequest {
+  after?: string;
+  limit?: number;
+  order?: string;
+}
 export const ListContainersContainersGetRequest = /*@__PURE__*/ S.suspend(() =>
-  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/containers", code: 200 })),
+  S.Struct({
+    after: S.optional(S.String.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    order: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/containers", code: 200 })),
 ).annotate({
   identifier: "ListContainersContainersGetRequest",
 }) as any as S.Schema<ListContainersContainersGetRequest>;
@@ -524,12 +532,18 @@ export const ListContainersContainersGetResponse = /*@__PURE__*/ S.suspend(() =>
   identifier: "ListContainersContainersGetResponse",
 }) as any as S.Schema<ListContainersContainersGetResponse>;
 
-export interface ListContainersV1ContainersGetRequest {}
+export interface ListContainersV1ContainersGetRequest {
+  after?: string;
+  limit?: number;
+  order?: string;
+}
 export const ListContainersV1ContainersGetRequest = /*@__PURE__*/ S.suspend(
   () =>
-    S.Struct({}).pipe(
-      T.Http({ method: "GET", uri: "/v1/containers", code: 200 }),
-    ),
+    S.Struct({
+      after: S.optional(S.String.pipe(T.Query())),
+      limit: S.optional(S.Number.pipe(T.Query())),
+      order: S.optional(S.String.pipe(T.Query())),
+    }).pipe(T.Http({ method: "GET", uri: "/v1/containers", code: 200 })),
 ).annotate({
   identifier: "ListContainersV1ContainersGetRequest",
 }) as any as S.Schema<ListContainersV1ContainersGetRequest>;
@@ -817,7 +831,9 @@ export const handlerMultipartUploadV1ContainersContainerIdFilesPost: API.Operati
   retry: Retry.Retry,
 }));
 
-export type ListContainersContainersGetError = LitellmOpError;
+export type ListContainersContainersGetError =
+  | UnprocessableEntity
+  | LitellmOpError;
 /** List Containers Container list endpoint for retrieving a list of containers. Follows the OpenAI Containers API spec: https://platform.openai.com/docs/api-reference/containers Example: ```bash curl -X GET "http://localhost:4000/v1/containers?limit=20&order=desc" -H "Authorization: Bearer sk-1234" ``` Or specify provider via header or query param: ```bash curl -X GET "http://localhost:4000/v1/containers?custom_llm_provider=azure" -H "Authorization: Bearer sk-1234" ``` */
 export const listContainersContainersGet: API.OperationMethod<
   ListContainersContainersGetRequest,
@@ -827,12 +843,14 @@ export const listContainersContainersGet: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: ListContainersContainersGetRequest,
   output: ListContainersContainersGetResponse,
-  errors: [],
+  errors: [UnprocessableEntity],
   protocol: LitellmProtocol,
   retry: Retry.Retry,
 }));
 
-export type ListContainersV1ContainersGetError = LitellmOpError;
+export type ListContainersV1ContainersGetError =
+  | UnprocessableEntity
+  | LitellmOpError;
 /** List Containers Container list endpoint for retrieving a list of containers. Follows the OpenAI Containers API spec: https://platform.openai.com/docs/api-reference/containers Example: ```bash curl -X GET "http://localhost:4000/v1/containers?limit=20&order=desc" -H "Authorization: Bearer sk-1234" ``` Or specify provider via header or query param: ```bash curl -X GET "http://localhost:4000/v1/containers?custom_llm_provider=azure" -H "Authorization: Bearer sk-1234" ``` */
 export const listContainersV1ContainersGet: API.OperationMethod<
   ListContainersV1ContainersGetRequest,
@@ -842,7 +860,7 @@ export const listContainersV1ContainersGet: API.OperationMethod<
 > = /*@__PURE__*/ API.make(() => ({
   input: ListContainersV1ContainersGetRequest,
   output: ListContainersV1ContainersGetResponse,
-  errors: [],
+  errors: [UnprocessableEntity],
   protocol: LitellmProtocol,
   retry: Retry.Retry,
 }));

package/src/services/coordination_redis_settings.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as C from "@distilled.cloud/core/category";

package/src/services/cost_tracking.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as C from "@distilled.cloud/core/category";
@@ -92,6 +92,10 @@ export const GetCostMarginConfigConfigCostMarginConfigGetResponse =
   }) as any as S.Schema<GetCostMarginConfigConfigCostMarginConfigGetResponse>;
 
 export interface PostEstimateCostCostEstimateRequest {
+  /** Input tokens written to the prompt cache; counted within input_tokens */
+  cache_creation_input_tokens?: number;
+  /** Input tokens read from the prompt cache; counted within input_tokens */
+  cache_read_input_tokens?: number;
   /** Expected input tokens per request */
   input_tokens: number;
   /** Model name (from /model_group/info) */
@@ -102,14 +106,19 @@ export interface PostEstimateCostCostEstimateRequest {
   num_requests_per_month?: number | null;
   /** Expected output tokens per request */
   output_tokens: number;
+  /** Reasoning tokens the model emits; counted within output_tokens */
+  reasoning_tokens?: number;
 }
 export const PostEstimateCostCostEstimateRequest = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
+    cache_creation_input_tokens: S.optional(S.Number),
+    cache_read_input_tokens: S.optional(S.Number),
     input_tokens: S.Number,
     model: S.String,
     num_requests_per_day: S.optional(S.NullOr(S.Number)),
     num_requests_per_month: S.optional(S.NullOr(S.Number)),
     output_tokens: S.Number,
+    reasoning_tokens: S.optional(S.Number),
   }).pipe(T.Http({ method: "POST", uri: "/cost/estimate", code: 200 })),
 ).annotate({
   identifier: "PostEstimateCostCostEstimateRequest",
@@ -117,8 +126,22 @@ export const PostEstimateCostCostEstimateRequest = /*@__PURE__*/ S.suspend(() =>
 
 /** Response body for /cost/estimate endpoint. */
 export interface CostEstimateResponse {
+  /** Cache-write share of input_cost_per_request */
+  cache_creation_cost_per_request?: number;
+  /** Rate billed per cache-write token */
+  cache_creation_input_token_cost?: number | null;
+  cache_creation_input_tokens?: number;
+  /** Cache-read share of input_cost_per_request */
+  cache_read_cost_per_request?: number;
+  /** Rate billed per cache-read token */
+  cache_read_input_token_cost?: number | null;
+  cache_read_input_tokens?: number;
   /** Total cost per request (includes margin) */
   cost_per_request: number;
+  /** Cache-write share of daily_input_cost */
+  daily_cache_creation_cost?: number | null;
+  /** Cache-read share of daily_input_cost */
+  daily_cache_read_cost?: number | null;
   /** Total daily cost (includes margin) */
   daily_cost?: number | null;
   /** Daily input token cost */
@@ -127,13 +150,20 @@ export interface CostEstimateResponse {
   daily_margin_cost?: number | null;
   /** Daily output token cost */
   daily_output_cost?: number | null;
+  /** Reasoning share of daily_output_cost */
+  daily_reasoning_cost?: number | null;
   /** Input token cost per request (before margin) */
   input_cost_per_request: number;
+  /** Rate billed per input token */
   input_cost_per_token?: number | null;
   input_tokens: number;
   /** Margin/fee added per request */
   margin_cost_per_request?: number;
   model: string;
+  /** Cache-write share of monthly_input_cost */
+  monthly_cache_creation_cost?: number | null;
+  /** Cache-read share of monthly_input_cost */
+  monthly_cache_read_cost?: number | null;
   /** Total monthly cost (includes margin) */
   monthly_cost?: number | null;
   /** Monthly input token cost */
@@ -142,41 +172,190 @@ export interface CostEstimateResponse {
   monthly_margin_cost?: number | null;
   /** Monthly output token cost */
   monthly_output_cost?: number | null;
+  /** Reasoning share of monthly_output_cost */
+  monthly_reasoning_cost?: number | null;
   num_requests_per_day?: number | null;
   num_requests_per_month?: number | null;
+  /** Rate billed per reasoning token */
+  output_cost_per_reasoning_token?: number | null;
   /** Output token cost per request (before margin) */
   output_cost_per_request: number;
+  /** Rate billed per output token */
   output_cost_per_token?: number | null;
   output_tokens: number;
   provider?: string | null;
+  /** Reasoning share of output_cost_per_request */
+  reasoning_cost_per_request?: number;
+  reasoning_tokens?: number;
 }
 export const CostEstimateResponse = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
+    cache_creation_cost_per_request: S.optional(S.Number),
+    cache_creation_input_token_cost: S.optional(S.NullOr(S.Number)),
+    cache_creation_input_tokens: S.optional(S.Number),
+    cache_read_cost_per_request: S.optional(S.Number),
+    cache_read_input_token_cost: S.optional(S.NullOr(S.Number)),
+    cache_read_input_tokens: S.optional(S.Number),
     cost_per_request: S.Number,
+    daily_cache_creation_cost: S.optional(S.NullOr(S.Number)),
+    daily_cache_read_cost: S.optional(S.NullOr(S.Number)),
     daily_cost: S.optional(S.NullOr(S.Number)),
     daily_input_cost: S.optional(S.NullOr(S.Number)),
     daily_margin_cost: S.optional(S.NullOr(S.Number)),
     daily_output_cost: S.optional(S.NullOr(S.Number)),
+    daily_reasoning_cost: S.optional(S.NullOr(S.Number)),
     input_cost_per_request: S.Number,
     input_cost_per_token: S.optional(S.NullOr(S.Number)),
     input_tokens: S.Number,
     margin_cost_per_request: S.optional(S.Number),
     model: S.String,
+    monthly_cache_creation_cost: S.optional(S.NullOr(S.Number)),
+    monthly_cache_read_cost: S.optional(S.NullOr(S.Number)),
     monthly_cost: S.optional(S.NullOr(S.Number)),
     monthly_input_cost: S.optional(S.NullOr(S.Number)),
     monthly_margin_cost: S.optional(S.NullOr(S.Number)),
     monthly_output_cost: S.optional(S.NullOr(S.Number)),
+    monthly_reasoning_cost: S.optional(S.NullOr(S.Number)),
     num_requests_per_day: S.optional(S.NullOr(S.Number)),
     num_requests_per_month: S.optional(S.NullOr(S.Number)),
+    output_cost_per_reasoning_token: S.optional(S.NullOr(S.Number)),
     output_cost_per_request: S.Number,
     output_cost_per_token: S.optional(S.NullOr(S.Number)),
     output_tokens: S.Number,
     provider: S.optional(S.NullOr(S.String)),
+    reasoning_cost_per_request: S.optional(S.Number),
+    reasoning_tokens: S.optional(S.Number),
   }),
 ).annotate({
   identifier: "CostEstimateResponse",
 }) as any as S.Schema<CostEstimateResponse>;
 
+export type PostPredictCacheCostCostPredictCacheRequestRequestMap = {
+  [key: string]: unknown | undefined;
+};
+export const PostPredictCacheCostCostPredictCacheRequestRequestMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as S.Schema<PostPredictCacheCostCostPredictCacheRequestRequestMap>;
+
+export interface PostPredictCacheCostCostPredictCacheRequest {
+  candidate_deployment_id: string;
+  current_deployment_id: string;
+  request: PostPredictCacheCostCostPredictCacheRequestRequestMap;
+}
+export const PostPredictCacheCostCostPredictCacheRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      candidate_deployment_id: S.String,
+      current_deployment_id: S.String,
+      request: PostPredictCacheCostCostPredictCacheRequestRequestMap,
+    }).pipe(T.Http({ method: "POST", uri: "/cost/predict-cache", code: 200 })),
+  ).annotate({
+    identifier: "PostPredictCacheCostCostPredictCacheRequest",
+  }) as any as S.Schema<PostPredictCacheCostCostPredictCacheRequest>;
+
+export type CachePredictionArmCacheState =
+  | "warm"
+  | "partial"
+  | "stale"
+  | "unknown"
+  | "disabled";
+export const CachePredictionArmCacheState = S.String;
+
+export interface CacheTokenBuckets {
+  cache_creation_1h_input_tokens?: number;
+  cache_creation_5m_input_tokens?: number;
+  cache_read_input_tokens?: number;
+  uncached_input_tokens?: number;
+}
+export const CacheTokenBuckets = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cache_creation_1h_input_tokens: S.optional(S.Number),
+    cache_creation_5m_input_tokens: S.optional(S.Number),
+    cache_read_input_tokens: S.optional(S.Number),
+    uncached_input_tokens: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "CacheTokenBuckets",
+}) as any as S.Schema<CacheTokenBuckets>;
+
+export interface CacheCostScenario {
+  input_cost: number;
+  tokens: CacheTokenBuckets;
+}
+export const CacheCostScenario = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    input_cost: S.Number,
+    tokens: CacheTokenBuckets,
+  }),
+).annotate({
+  identifier: "CacheCostScenario",
+}) as any as S.Schema<CacheCostScenario>;
+
+export interface CacheEvidence {
+  confidence?: string;
+  expires_at: number;
+  observed_at: number;
+  source?: string;
+}
+export const CacheEvidence = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    confidence: S.optional(S.String),
+    expires_at: S.Number,
+    observed_at: S.Number,
+    source: S.optional(S.String),
+  }),
+).annotate({ identifier: "CacheEvidence" }) as any as S.Schema<CacheEvidence>;
+
+export interface CachePredictionArm {
+  cache_state?: CachePredictionArmCacheState;
+  cold?: CacheCostScenario | null;
+  deployment_id: string;
+  estimate?: CacheCostScenario | null;
+  evidence?: CacheEvidence | null;
+  model?: string | null;
+  reason?: string | null;
+  token_count_source?: string | null;
+  warm?: CacheCostScenario | null;
+}
+export const CachePredictionArm = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cache_state: S.optional(CachePredictionArmCacheState),
+    cold: S.optional(S.NullOr(CacheCostScenario)),
+    deployment_id: S.String,
+    estimate: S.optional(S.NullOr(CacheCostScenario)),
+    evidence: S.optional(S.NullOr(CacheEvidence)),
+    model: S.optional(S.NullOr(S.String)),
+    reason: S.optional(S.NullOr(S.String)),
+    token_count_source: S.optional(S.NullOr(S.String)),
+    warm: S.optional(S.NullOr(CacheCostScenario)),
+  }),
+).annotate({
+  identifier: "CachePredictionArm",
+}) as any as S.Schema<CachePredictionArm>;
+
+export interface CachePredictionResponse {
+  cache_guarantee?: boolean;
+  cache_rebuild_penalty: number | null;
+  pricing_basis?: string;
+  stay: CachePredictionArm;
+  switch: CachePredictionArm;
+  switch_delta: number | null;
+}
+export const CachePredictionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cache_guarantee: S.optional(S.Boolean),
+    cache_rebuild_penalty: S.NullOr(S.Number),
+    pricing_basis: S.optional(S.String),
+    stay: CachePredictionArm,
+    switch: CachePredictionArm,
+    switch_delta: S.NullOr(S.Number),
+  }),
+).annotate({
+  identifier: "CachePredictionResponse",
+}) as any as S.Schema<CachePredictionResponse>;
+
 export interface UpdateBlockRequestsForModelsWithoutPricingConfigBlockRequestsForModelsWithoutPricingPatchRequest {
   enabled: boolean;
 }
@@ -340,7 +519,7 @@ export const getCostMarginConfigConfigCostMarginConfigGet: API.OperationMethod<
 export type PostEstimateCostCostEstimateError =
   | UnprocessableEntity
   | LitellmOpError;
-/** Estimate Cost Estimate cost for a given model and token counts. This endpoint uses the same cost calculation logic as actual requests, including any configured margins and discounts. Parameters: - model: Model name (e.g., "gpt-4", "claude-3-opus") - input_tokens: Expected input tokens per request - output_tokens: Expected output tokens per request - num_requests_per_day: Number of requests per day (optional) - num_requests_per_month: Number of requests per month (optional) Returns cost breakdown including: - Per-request costs (input, output, margin) - Daily costs (if num_requests_per_day provided) - Monthly costs (if num_requests_per_month provided) Example: ```json { "model": "gpt-4", "input_tokens": 1000, "output_tokens": 500, "num_requests_per_day": 100, "num_requests_per_month": 3000 } ``` */
+/** Estimate Cost Estimate cost for a given model and token counts. This endpoint uses the same cost calculation logic as actual requests, including any configured margins and discounts. Parameters: - model: Model name (e.g., "gpt-4", "claude-3-opus") - input_tokens: Expected input tokens per request - output_tokens: Expected output tokens per request - cache_read_input_tokens: Cache-read tokens per request, counted within input_tokens (optional) - cache_creation_input_tokens: Cache-write tokens per request, counted within input_tokens (optional) - reasoning_tokens: Reasoning tokens per request, counted within output_tokens (optional) - num_requests_per_day: Number of requests per day (optional) - num_requests_per_month: Number of requests per month (optional) Returns cost breakdown including: - Per-request costs (input, output, margin, plus the cache-read, cache-write and reasoning shares) - Daily costs (if num_requests_per_day provided) - Monthly costs (if num_requests_per_month provided) Example: ```json { "model": "gpt-4", "input_tokens": 1000, "cache_read_input_tokens": 800, "output_tokens": 500, "reasoning_tokens": 200, "num_requests_per_day": 100, "num_requests_per_month": 3000 } ``` */
 export const postEstimateCostCostEstimate: API.OperationMethod<
   PostEstimateCostCostEstimateRequest,
   CostEstimateResponse,
@@ -354,6 +533,23 @@ export const postEstimateCostCostEstimate: API.OperationMethod<
   retry: Retry.Retry,
 }));
 
+export type PostPredictCacheCostCostPredictCacheError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Predict Cache Cost Compare the next native Anthropic request on two configured deployment IDs. Estimates use provider token counting and recent successful cache telemetry for this key. Unknown cache state uses the cold scenario when prices/counts are available. Cache observations do not guarantee retention. v0 supports one message-content breakpoint, text and client tools; system/tool-only breakpoints, thinking, images, nondefault Anthropic versions, beta headers and request transforms are unknown. Each provider count consumes one RPM unit and holds concurrency capacity; a comparison uses up to four counts. The legacy rate limiter returns unknown without contacting the provider. This endpoint does not generate tokens, prewarm caches, choose a model or alter routing. */
+export const postPredictCacheCostCostPredictCache: API.OperationMethod<
+  PostPredictCacheCostCostPredictCacheRequest,
+  CachePredictionResponse,
+  PostPredictCacheCostCostPredictCacheError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostPredictCacheCostCostPredictCacheRequest,
+  output: CachePredictionResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
 export type UpdateBlockRequestsForModelsWithoutPricingConfigBlockRequestsForModelsWithoutPricingPatchError =
   | UnprocessableEntity
   | LitellmOpError;

package/src/services/credential_management.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as C from "@distilled.cloud/core/category";
@@ -12,6 +12,16 @@ import * as Retry from "../retry.ts";
 
 export type { LitellmOpError, LitellmOpContext };
 
+/** No credential matches the name a by-name read or delete asked for (the proxy holds no such row, or another caller deleted it first). LiteLLM answers 404 with the message `Credential not found`. Whether the row still exists is the caller's re-read, never this error. */
+export class CredentialNotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<CredentialNotFound>()("CredentialNotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404, message: { includes: "Credential not found" } }],
+  ) {}
+
 export class UnprocessableEntity
   extends /*@__PURE__*/ T.applyErrorMatchers(
     /*@__PURE__*/ S.TaggedError<UnprocessableEntity>()("UnprocessableEntity", {
@@ -269,7 +279,9 @@ export interface UpdateCredentialCredentialsCredentialNamePatchRequest {
   /** The credential name, percent-decoded; may contain slashes */
   credential_name: string;
   credential_info: UpdateCredentialCredentialsCredentialNamePatchRequestCredentialInfoMap;
-  credential_values: UpdateCredentialCredentialsCredentialNamePatchRequestCredentialValuesMap;
+  credential_values?: UpdateCredentialCredentialsCredentialNamePatchRequestCredentialValuesMap | null;
+  model_id?: string | null;
+  credential_name_body: string;
 }
 export const UpdateCredentialCredentialsCredentialNamePatchRequest =
   /*@__PURE__*/ S.suspend(() =>
@@ -277,8 +289,13 @@ export const UpdateCredentialCredentialsCredentialNamePatchRequest =
       credential_name: S.String.pipe(T.Label()),
       credential_info:
         UpdateCredentialCredentialsCredentialNamePatchRequestCredentialInfoMap,
-      credential_values:
-        UpdateCredentialCredentialsCredentialNamePatchRequestCredentialValuesMap,
+      credential_values: S.optional(
+        S.NullOr(
+          UpdateCredentialCredentialsCredentialNamePatchRequestCredentialValuesMap,
+        ),
+      ),
+      model_id: S.optional(S.NullOr(S.String)),
+      credential_name_body: S.String.pipe(T.Body("credential_name")),
     }).pipe(
       T.Http({
         method: "PATCH",
@@ -337,6 +354,7 @@ export const createCredentialCredentialsPost: API.OperationMethod<
 
 export type DeleteCredentialCredentialsCredentialNameDeleteError =
   | UnprocessableEntity
+  | CredentialNotFound
   | LitellmOpError;
 /** Delete Credential [BETA] endpoint. This might change unexpectedly. */
 export const deleteCredentialCredentialsCredentialNameDelete: API.OperationMethod<
@@ -347,7 +365,7 @@ export const deleteCredentialCredentialsCredentialNameDelete: API.OperationMetho
 > = /*@__PURE__*/ API.make(() => ({
   input: DeleteCredentialCredentialsCredentialNameDeleteRequest,
   output: DeleteCredentialCredentialsCredentialNameDeleteResponse,
-  errors: [UnprocessableEntity],
+  errors: [UnprocessableEntity, CredentialNotFound],
   protocol: LitellmProtocol,
   retry: Retry.Retry,
 }));
@@ -371,6 +389,7 @@ export const getCredentialByModelCredentialsByModelModelIdGet: API.OperationMeth
 
 export type GetCredentialByNameCredentialsByNameCredentialNameGetError =
   | UnprocessableEntity
+  | CredentialNotFound
   | LitellmOpError;
 /** Get Credential By Name [BETA] endpoint. This might change unexpectedly. */
 export const getCredentialByNameCredentialsByNameCredentialNameGet: API.OperationMethod<
@@ -381,7 +400,7 @@ export const getCredentialByNameCredentialsByNameCredentialNameGet: API.Operatio
 > = /*@__PURE__*/ API.make(() => ({
   input: GetCredentialByNameCredentialsByNameCredentialNameGetRequest,
   output: CredentialItem,
-  errors: [UnprocessableEntity],
+  errors: [UnprocessableEntity, CredentialNotFound],
   protocol: LitellmProtocol,
   retry: Retry.Retry,
 }));