@homeflare/distilled-litellm 0.2.0

package/src/services/moderations.ts

@@ -0,0 +1,80 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  LitellmProtocol,
+  type LitellmOpError,
+  type LitellmOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { LitellmOpError, LitellmOpContext };
+
+export interface PostModerationsModerationRequest {}
+export const PostModerationsModerationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "POST", uri: "/moderations", code: 200 })),
+).annotate({
+  identifier: "PostModerationsModerationRequest",
+}) as any as S.Schema<PostModerationsModerationRequest>;
+
+export interface PostModerationsModerationResponse {
+  body: unknown;
+}
+export const PostModerationsModerationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "PostModerationsModerationResponse",
+}) as any as S.Schema<PostModerationsModerationResponse>;
+
+export interface PostModerationsV1ModerationRequest {}
+export const PostModerationsV1ModerationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "POST", uri: "/v1/moderations", code: 200 }),
+  ),
+).annotate({
+  identifier: "PostModerationsV1ModerationRequest",
+}) as any as S.Schema<PostModerationsV1ModerationRequest>;
+
+export interface PostModerationsV1ModerationResponse {
+  body: unknown;
+}
+export const PostModerationsV1ModerationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "PostModerationsV1ModerationResponse",
+}) as any as S.Schema<PostModerationsV1ModerationResponse>;
+
+export type PostModerationsModerationError = LitellmOpError;
+/** Moderations The moderations endpoint is a tool you can use to check whether content complies with an LLM Providers policies. Quick Start ``` curl --location 'http://0.0.0.0:4000/moderations' --header 'Content-Type: application/json' --header 'Authorization: Bearer sk-1234' --data '{"input": "Sample text goes here", "model": "text-moderation-stable"}' ``` */
+export const postModerationsModeration: API.OperationMethod<
+  PostModerationsModerationRequest,
+  PostModerationsModerationResponse,
+  PostModerationsModerationError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostModerationsModerationRequest,
+  output: PostModerationsModerationResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostModerationsV1ModerationError = LitellmOpError;
+/** Moderations The moderations endpoint is a tool you can use to check whether content complies with an LLM Providers policies. Quick Start ``` curl --location 'http://0.0.0.0:4000/moderations' --header 'Content-Type: application/json' --header 'Authorization: Bearer sk-1234' --data '{"input": "Sample text goes here", "model": "text-moderation-stable"}' ``` */
+export const postModerationsV1Moderation: API.OperationMethod<
+  PostModerationsV1ModerationRequest,
+  PostModerationsV1ModerationResponse,
+  PostModerationsV1ModerationError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostModerationsV1ModerationRequest,
+  output: PostModerationsV1ModerationResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/ocr.ts

@@ -0,0 +1,78 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  LitellmProtocol,
+  type LitellmOpError,
+  type LitellmOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { LitellmOpError, LitellmOpContext };
+
+export interface PostOcrOcrRequest {}
+export const PostOcrOcrRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "POST", uri: "/ocr", code: 200 })),
+).annotate({
+  identifier: "PostOcrOcrRequest",
+}) as any as S.Schema<PostOcrOcrRequest>;
+
+export interface PostOcrOcrResponse {
+  body: unknown;
+}
+export const PostOcrOcrResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "PostOcrOcrResponse",
+}) as any as S.Schema<PostOcrOcrResponse>;
+
+export interface PostOcrV1OcrRequest {}
+export const PostOcrV1OcrRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "POST", uri: "/v1/ocr", code: 200 })),
+).annotate({
+  identifier: "PostOcrV1OcrRequest",
+}) as any as S.Schema<PostOcrV1OcrRequest>;
+
+export interface PostOcrV1OcrResponse {
+  body: unknown;
+}
+export const PostOcrV1OcrResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "PostOcrV1OcrResponse",
+}) as any as S.Schema<PostOcrV1OcrResponse>;
+
+export type PostOcrOcrError = LitellmOpError;
+/** Ocr OCR endpoint for extracting text from documents and images. Supports two input modes: **1. JSON body** (Mistral OCR API compatible): ```bash curl -X POST "http://localhost:4000/v1/ocr" -H "Authorization: Bearer sk-1234" -H "Content-Type: application/json" -d '{ "model": "mistral-ocr", "document": { "type": "document_url", "document_url": "https://arxiv.org/pdf/2201.04234" } }' ``` **2. Multipart form file upload**: ```bash curl -X POST "http://localhost:4000/v1/ocr" -H "Authorization: Bearer sk-1234" -F "model=mistral-ocr" -F "file=@document.pdf" ``` Response format is normalized to the LiteLLM OCR schema by default. Providers that support it (Azure Document Intelligence) can return their own payload instead, with cost tracking unchanged, via `x-req-format: native` (or `"req_format": "native"` in the body). */
+export const postOcrOcr: API.OperationMethod<
+  PostOcrOcrRequest,
+  PostOcrOcrResponse,
+  PostOcrOcrError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostOcrOcrRequest,
+  output: PostOcrOcrResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostOcrV1OcrError = LitellmOpError;
+/** Ocr OCR endpoint for extracting text from documents and images. Supports two input modes: **1. JSON body** (Mistral OCR API compatible): ```bash curl -X POST "http://localhost:4000/v1/ocr" -H "Authorization: Bearer sk-1234" -H "Content-Type: application/json" -d '{ "model": "mistral-ocr", "document": { "type": "document_url", "document_url": "https://arxiv.org/pdf/2201.04234" } }' ``` **2. Multipart form file upload**: ```bash curl -X POST "http://localhost:4000/v1/ocr" -H "Authorization: Bearer sk-1234" -F "model=mistral-ocr" -F "file=@document.pdf" ``` Response format is normalized to the LiteLLM OCR schema by default. Providers that support it (Azure Document Intelligence) can return their own payload instead, with cost tracking unchanged, via `x-req-format: native` (or `"req_format": "native"` in the body). */
+export const postOcrV1Ocr: API.OperationMethod<
+  PostOcrV1OcrRequest,
+  PostOcrV1OcrResponse,
+  PostOcrV1OcrError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostOcrV1OcrRequest,
+  output: PostOcrV1OcrResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/open_ai_pass_through.ts

@@ -0,0 +1,462 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.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";
+import * as T from "../traits.ts";
+import {
+  LitellmProtocol,
+  type LitellmOpError,
+  type LitellmOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { LitellmOpError, LitellmOpContext };
+
+export class UnprocessableEntity
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<UnprocessableEntity>()("UnprocessableEntity", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 422 }],
+  ) {}
+
+export interface DeleteOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const DeleteOpenaiProxyRouteOpenaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "DELETE", uri: "/openai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "DeleteOpenaiProxyRouteOpenaiEndpointRequest",
+  }) as any as S.Schema<DeleteOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface DeleteOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const DeleteOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<DeleteOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface DeleteOpenaiProxyRouteOpenaiPassthroughEndpointRequest {
+  endpoint: string;
+}
+export const DeleteOpenaiProxyRouteOpenaiPassthroughEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/openai_passthrough/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteOpenaiProxyRouteOpenaiPassthroughEndpointRequest",
+  }) as any as S.Schema<DeleteOpenaiProxyRouteOpenaiPassthroughEndpointRequest>;
+
+export interface DeleteOpenaiProxyRouteOpenaiPassthroughEndpointResponse {
+  body: unknown;
+}
+export const DeleteOpenaiProxyRouteOpenaiPassthroughEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteOpenaiProxyRouteOpenaiPassthroughEndpointResponse",
+  }) as any as S.Schema<DeleteOpenaiProxyRouteOpenaiPassthroughEndpointResponse>;
+
+export interface GetOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const GetOpenaiProxyRouteOpenaiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/openai/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "GetOpenaiProxyRouteOpenaiEndpointRequest",
+}) as any as S.Schema<GetOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface GetOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const GetOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<GetOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface GetOpenaiProxyRouteOpenaiPassthroughEndpointRequest {
+  endpoint: string;
+}
+export const GetOpenaiProxyRouteOpenaiPassthroughEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/openai_passthrough/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetOpenaiProxyRouteOpenaiPassthroughEndpointRequest",
+  }) as any as S.Schema<GetOpenaiProxyRouteOpenaiPassthroughEndpointRequest>;
+
+export interface GetOpenaiProxyRouteOpenaiPassthroughEndpointResponse {
+  body: unknown;
+}
+export const GetOpenaiProxyRouteOpenaiPassthroughEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetOpenaiProxyRouteOpenaiPassthroughEndpointResponse",
+  }) as any as S.Schema<GetOpenaiProxyRouteOpenaiPassthroughEndpointResponse>;
+
+export interface PatchOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const PatchOpenaiProxyRouteOpenaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PATCH", uri: "/openai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PatchOpenaiProxyRouteOpenaiEndpointRequest",
+  }) as any as S.Schema<PatchOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface PatchOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const PatchOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<PatchOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface PatchOpenaiProxyRouteOpenaiPassthroughEndpointRequest {
+  endpoint: string;
+}
+export const PatchOpenaiProxyRouteOpenaiPassthroughEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "PATCH",
+        uri: "/openai_passthrough/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PatchOpenaiProxyRouteOpenaiPassthroughEndpointRequest",
+  }) as any as S.Schema<PatchOpenaiProxyRouteOpenaiPassthroughEndpointRequest>;
+
+export interface PatchOpenaiProxyRouteOpenaiPassthroughEndpointResponse {
+  body: unknown;
+}
+export const PatchOpenaiProxyRouteOpenaiPassthroughEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchOpenaiProxyRouteOpenaiPassthroughEndpointResponse",
+  }) as any as S.Schema<PatchOpenaiProxyRouteOpenaiPassthroughEndpointResponse>;
+
+export interface PostOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const PostOpenaiProxyRouteOpenaiEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "POST", uri: "/openai/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PostOpenaiProxyRouteOpenaiEndpointRequest",
+  }) as any as S.Schema<PostOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface PostOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const PostOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<PostOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface PostOpenaiProxyRouteOpenaiPassthroughEndpointRequest {
+  endpoint: string;
+}
+export const PostOpenaiProxyRouteOpenaiPassthroughEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/openai_passthrough/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PostOpenaiProxyRouteOpenaiPassthroughEndpointRequest",
+  }) as any as S.Schema<PostOpenaiProxyRouteOpenaiPassthroughEndpointRequest>;
+
+export interface PostOpenaiProxyRouteOpenaiPassthroughEndpointResponse {
+  body: unknown;
+}
+export const PostOpenaiProxyRouteOpenaiPassthroughEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostOpenaiProxyRouteOpenaiPassthroughEndpointResponse",
+  }) as any as S.Schema<PostOpenaiProxyRouteOpenaiPassthroughEndpointResponse>;
+
+export interface PutOpenaiProxyRouteOpenaiEndpointRequest {
+  endpoint: string;
+}
+export const PutOpenaiProxyRouteOpenaiEndpointRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/openai/{endpoint}", code: 200 })),
+).annotate({
+  identifier: "PutOpenaiProxyRouteOpenaiEndpointRequest",
+}) as any as S.Schema<PutOpenaiProxyRouteOpenaiEndpointRequest>;
+
+export interface PutOpenaiProxyRouteOpenaiEndpointResponse {
+  body: unknown;
+}
+export const PutOpenaiProxyRouteOpenaiEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutOpenaiProxyRouteOpenaiEndpointResponse",
+  }) as any as S.Schema<PutOpenaiProxyRouteOpenaiEndpointResponse>;
+
+export interface PutOpenaiProxyRouteOpenaiPassthroughEndpointRequest {
+  endpoint: string;
+}
+export const PutOpenaiProxyRouteOpenaiPassthroughEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "PUT",
+        uri: "/openai_passthrough/{endpoint}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "PutOpenaiProxyRouteOpenaiPassthroughEndpointRequest",
+  }) as any as S.Schema<PutOpenaiProxyRouteOpenaiPassthroughEndpointRequest>;
+
+export interface PutOpenaiProxyRouteOpenaiPassthroughEndpointResponse {
+  body: unknown;
+}
+export const PutOpenaiProxyRouteOpenaiPassthroughEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutOpenaiProxyRouteOpenaiPassthroughEndpointResponse",
+  }) as any as S.Schema<PutOpenaiProxyRouteOpenaiPassthroughEndpointResponse>;
+
+export type DeleteOpenaiProxyRouteOpenaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const deleteOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  DeleteOpenaiProxyRouteOpenaiEndpointRequest,
+  DeleteOpenaiProxyRouteOpenaiEndpointResponse,
+  DeleteOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOpenaiProxyRouteOpenaiEndpointRequest,
+  output: DeleteOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOpenaiProxyRouteOpenaiPassthroughEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const deleteOpenaiProxyRouteOpenaiPassthroughEndpoint: API.OperationMethod<
+  DeleteOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  DeleteOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  DeleteOpenaiProxyRouteOpenaiPassthroughEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  output: DeleteOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOpenaiProxyRouteOpenaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const getOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  GetOpenaiProxyRouteOpenaiEndpointRequest,
+  GetOpenaiProxyRouteOpenaiEndpointResponse,
+  GetOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOpenaiProxyRouteOpenaiEndpointRequest,
+  output: GetOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOpenaiProxyRouteOpenaiPassthroughEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const getOpenaiProxyRouteOpenaiPassthroughEndpoint: API.OperationMethod<
+  GetOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  GetOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  GetOpenaiProxyRouteOpenaiPassthroughEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  output: GetOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchOpenaiProxyRouteOpenaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const patchOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  PatchOpenaiProxyRouteOpenaiEndpointRequest,
+  PatchOpenaiProxyRouteOpenaiEndpointResponse,
+  PatchOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchOpenaiProxyRouteOpenaiEndpointRequest,
+  output: PatchOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchOpenaiProxyRouteOpenaiPassthroughEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const patchOpenaiProxyRouteOpenaiPassthroughEndpoint: API.OperationMethod<
+  PatchOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  PatchOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  PatchOpenaiProxyRouteOpenaiPassthroughEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  output: PatchOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostOpenaiProxyRouteOpenaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const postOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  PostOpenaiProxyRouteOpenaiEndpointRequest,
+  PostOpenaiProxyRouteOpenaiEndpointResponse,
+  PostOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostOpenaiProxyRouteOpenaiEndpointRequest,
+  output: PostOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostOpenaiProxyRouteOpenaiPassthroughEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const postOpenaiProxyRouteOpenaiPassthroughEndpoint: API.OperationMethod<
+  PostOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  PostOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  PostOpenaiProxyRouteOpenaiPassthroughEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  output: PostOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutOpenaiProxyRouteOpenaiEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const putOpenaiProxyRouteOpenaiEndpoint: API.OperationMethod<
+  PutOpenaiProxyRouteOpenaiEndpointRequest,
+  PutOpenaiProxyRouteOpenaiEndpointResponse,
+  PutOpenaiProxyRouteOpenaiEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOpenaiProxyRouteOpenaiEndpointRequest,
+  output: PutOpenaiProxyRouteOpenaiEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutOpenaiProxyRouteOpenaiPassthroughEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Openai Proxy Route Pass-through endpoint for OpenAI API calls. Available on both routes: - /openai/{endpoint:path} - Standard OpenAI passthrough route - /openai_passthrough/{endpoint:path} - Dedicated passthrough route (recommended for Responses API) Use /openai_passthrough/* when you need guaranteed passthrough to OpenAI without conflicts with LiteLLM's native implementations (e.g., for the Responses API at /v1/responses). Examples: Standard route: - /openai/v1/chat/completions - /openai/v1/assistants - /openai/v1/threads Dedicated passthrough (for Responses API): - /openai_passthrough/v1/responses - /openai_passthrough/v1/responses/{response_id} - /openai_passthrough/v1/responses/{response_id}/input_items [Docs](https://docs.litellm.ai/docs/pass_through/openai_passthrough) */
+export const putOpenaiProxyRouteOpenaiPassthroughEndpoint: API.OperationMethod<
+  PutOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  PutOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  PutOpenaiProxyRouteOpenaiPassthroughEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutOpenaiProxyRouteOpenaiPassthroughEndpointRequest,
+  output: PutOpenaiProxyRouteOpenaiPassthroughEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));