@homeflare/distilled-litellm 0.2.0

package/src/services/alerting.ts

@@ -0,0 +1,49 @@
+// 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 GetAlertingSettingsAlertingSettingsRequest {}
+export const GetAlertingSettingsAlertingSettingsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/alerting/settings", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetAlertingSettingsAlertingSettingsRequest",
+  }) as any as S.Schema<GetAlertingSettingsAlertingSettingsRequest>;
+
+export interface GetAlertingSettingsAlertingSettingsResponse {
+  body: unknown;
+}
+export const GetAlertingSettingsAlertingSettingsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAlertingSettingsAlertingSettingsResponse",
+  }) as any as S.Schema<GetAlertingSettingsAlertingSettingsResponse>;
+
+export type GetAlertingSettingsAlertingSettingsError = LitellmOpError;
+/** Alerting Settings Return the configurable alerting param, description, and current value */
+export const getAlertingSettingsAlertingSettings: API.OperationMethod<
+  GetAlertingSettingsAlertingSettingsRequest,
+  GetAlertingSettingsAlertingSettingsResponse,
+  GetAlertingSettingsAlertingSettingsError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAlertingSettingsAlertingSettingsRequest,
+  output: GetAlertingSettingsAlertingSettingsResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/anthropic_pass_through.ts

@@ -0,0 +1,233 @@
+// 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 DeleteAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const DeleteAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/anthropic/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "DeleteAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<DeleteAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface DeleteAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const DeleteAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "DeleteAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<DeleteAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface GetAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const GetAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "GET", uri: "/anthropic/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "GetAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<GetAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface GetAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const GetAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "GetAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<GetAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface PatchAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const PatchAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "PATCH", uri: "/anthropic/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PatchAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<PatchAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface PatchAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const PatchAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PatchAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<PatchAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface PostAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const PostAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/anthropic/{endpoint}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<PostAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface PostAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const PostAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<PostAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export interface PutAnthropicProxyRouteAnthropicEndpointRequest {
+  endpoint: string;
+}
+export const PutAnthropicProxyRouteAnthropicEndpointRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      endpoint: S.String.pipe(T.Label()),
+    }).pipe(T.Http({ method: "PUT", uri: "/anthropic/{endpoint}", code: 200 })),
+  ).annotate({
+    identifier: "PutAnthropicProxyRouteAnthropicEndpointRequest",
+  }) as any as S.Schema<PutAnthropicProxyRouteAnthropicEndpointRequest>;
+
+export interface PutAnthropicProxyRouteAnthropicEndpointResponse {
+  body: unknown;
+}
+export const PutAnthropicProxyRouteAnthropicEndpointResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PutAnthropicProxyRouteAnthropicEndpointResponse",
+  }) as any as S.Schema<PutAnthropicProxyRouteAnthropicEndpointResponse>;
+
+export type DeleteAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const deleteAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  DeleteAnthropicProxyRouteAnthropicEndpointRequest,
+  DeleteAnthropicProxyRouteAnthropicEndpointResponse,
+  DeleteAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAnthropicProxyRouteAnthropicEndpointRequest,
+  output: DeleteAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const getAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  GetAnthropicProxyRouteAnthropicEndpointRequest,
+  GetAnthropicProxyRouteAnthropicEndpointResponse,
+  GetAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAnthropicProxyRouteAnthropicEndpointRequest,
+  output: GetAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PatchAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const patchAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  PatchAnthropicProxyRouteAnthropicEndpointRequest,
+  PatchAnthropicProxyRouteAnthropicEndpointResponse,
+  PatchAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PatchAnthropicProxyRouteAnthropicEndpointRequest,
+  output: PatchAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const postAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  PostAnthropicProxyRouteAnthropicEndpointRequest,
+  PostAnthropicProxyRouteAnthropicEndpointResponse,
+  PostAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAnthropicProxyRouteAnthropicEndpointRequest,
+  output: PostAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PutAnthropicProxyRouteAnthropicEndpointError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Anthropic Proxy Route [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion) */
+export const putAnthropicProxyRouteAnthropicEndpoint: API.OperationMethod<
+  PutAnthropicProxyRouteAnthropicEndpointRequest,
+  PutAnthropicProxyRouteAnthropicEndpointResponse,
+  PutAnthropicProxyRouteAnthropicEndpointError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutAnthropicProxyRouteAnthropicEndpointRequest,
+  output: PutAnthropicProxyRouteAnthropicEndpointResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/anthropic_passthrough.ts

@@ -0,0 +1,123 @@
+// 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 PostAnthropicResponseV1MessageRequest {}
+export const PostAnthropicResponseV1MessageRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/v1/messages", code: 200 }),
+    ),
+).annotate({
+  identifier: "PostAnthropicResponseV1MessageRequest",
+}) as any as S.Schema<PostAnthropicResponseV1MessageRequest>;
+
+export interface PostAnthropicResponseV1MessageResponse {
+  body: unknown;
+}
+export const PostAnthropicResponseV1MessageResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PostAnthropicResponseV1MessageResponse",
+}) as any as S.Schema<PostAnthropicResponseV1MessageResponse>;
+
+export interface PostCountTokensV1MessagesCountTokenRequest {}
+export const PostCountTokensV1MessagesCountTokenRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/v1/messages/count_tokens", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostCountTokensV1MessagesCountTokenRequest",
+  }) as any as S.Schema<PostCountTokensV1MessagesCountTokenRequest>;
+
+export interface PostCountTokensV1MessagesCountTokenResponse {
+  body: unknown;
+}
+export const PostCountTokensV1MessagesCountTokenResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostCountTokensV1MessagesCountTokenResponse",
+  }) as any as S.Schema<PostCountTokensV1MessagesCountTokenResponse>;
+
+export interface PostEventLoggingBatchApiEventLoggingBatchRequest {}
+export const PostEventLoggingBatchApiEventLoggingBatchRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/api/event_logging/batch", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "PostEventLoggingBatchApiEventLoggingBatchRequest",
+  }) as any as S.Schema<PostEventLoggingBatchApiEventLoggingBatchRequest>;
+
+export interface PostEventLoggingBatchApiEventLoggingBatchResponse {
+  body: unknown;
+}
+export const PostEventLoggingBatchApiEventLoggingBatchResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "PostEventLoggingBatchApiEventLoggingBatchResponse",
+  }) as any as S.Schema<PostEventLoggingBatchApiEventLoggingBatchResponse>;
+
+export type PostAnthropicResponseV1MessageError = LitellmOpError;
+/** Anthropic Response Use `{PROXY_BASE_URL}/anthropic/v1/messages` instead - [Docs](https://docs.litellm.ai/docs/pass_through/anthropic_completion). This was a BETA endpoint that calls 100+ LLMs in the anthropic format. */
+export const postAnthropicResponseV1Message: API.OperationMethod<
+  PostAnthropicResponseV1MessageRequest,
+  PostAnthropicResponseV1MessageResponse,
+  PostAnthropicResponseV1MessageError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostAnthropicResponseV1MessageRequest,
+  output: PostAnthropicResponseV1MessageResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostCountTokensV1MessagesCountTokenError = LitellmOpError;
+/** Count Tokens Count tokens for Anthropic Messages API format. This endpoint follows the Anthropic Messages API token counting specification. It accepts the same parameters as the /v1/messages endpoint but returns token counts instead of generating a response. Example usage: ``` curl -X POST "http://localhost:4000/v1/messages/count_tokens?beta=true" -H "Content-Type: application/json" -H "Authorization: Bearer your-key" -d '{ "model": "claude-3-sonnet-20240229", "messages": [{"role": "user", "content": "Hello Claude!"}] }' ``` Returns: {"input_tokens": <number>} */
+export const postCountTokensV1MessagesCountToken: API.OperationMethod<
+  PostCountTokensV1MessagesCountTokenRequest,
+  PostCountTokensV1MessagesCountTokenResponse,
+  PostCountTokensV1MessagesCountTokenError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostCountTokensV1MessagesCountTokenRequest,
+  output: PostCountTokensV1MessagesCountTokenResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostEventLoggingBatchApiEventLoggingBatchError = LitellmOpError;
+/** Event Logging Batch Stubbed endpoint for Anthropic event logging batch requests. This endpoint accepts event logging requests but does nothing with them. It exists to prevent 404 errors from Claude Code clients that send telemetry. */
+export const postEventLoggingBatchApiEventLoggingBatch: API.OperationMethod<
+  PostEventLoggingBatchApiEventLoggingBatchRequest,
+  PostEventLoggingBatchApiEventLoggingBatchResponse,
+  PostEventLoggingBatchApiEventLoggingBatchError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostEventLoggingBatchApiEventLoggingBatchRequest,
+  output: PostEventLoggingBatchApiEventLoggingBatchResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/anthropic_skills.ts

@@ -0,0 +1,200 @@
+// 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 CreateSkillV1SkillsPostRequest {
+  custom_llm_provider?: string;
+}
+export const CreateSkillV1SkillsPostRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    custom_llm_provider: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "POST", uri: "/v1/skills", code: 200 })),
+).annotate({
+  identifier: "CreateSkillV1SkillsPostRequest",
+}) as any as S.Schema<CreateSkillV1SkillsPostRequest>;
+
+/** Represents a skill from the Anthropic Skills API */
+export interface Skill {
+  created_at: string;
+  display_title?: string | null;
+  id: string;
+  latest_version?: string | null;
+  source: string;
+  type?: string;
+  updated_at: string;
+}
+export const Skill = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created_at: S.String,
+    display_title: S.optional(S.NullOr(S.String)),
+    id: S.String,
+    latest_version: S.optional(S.NullOr(S.String)),
+    source: S.String,
+    type: S.optional(S.String),
+    updated_at: S.String,
+  }),
+).annotate({ identifier: "Skill" }) as any as S.Schema<Skill>;
+
+export interface DeleteSkillV1SkillsSkillIdDeleteRequest {
+  skill_id: string;
+  custom_llm_provider?: string;
+}
+export const DeleteSkillV1SkillsSkillIdDeleteRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      skill_id: S.String.pipe(T.Label()),
+      custom_llm_provider: S.optional(S.String.pipe(T.Query())),
+    }).pipe(
+      T.Http({ method: "DELETE", uri: "/v1/skills/{skill_id}", code: 200 }),
+    ),
+).annotate({
+  identifier: "DeleteSkillV1SkillsSkillIdDeleteRequest",
+}) as any as S.Schema<DeleteSkillV1SkillsSkillIdDeleteRequest>;
+
+/** Response from deleting a skill */
+export interface DeleteSkillResponse {
+  id: string;
+  type?: string;
+}
+export const DeleteSkillResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    type: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "DeleteSkillResponse",
+}) as any as S.Schema<DeleteSkillResponse>;
+
+export interface GetSkillV1SkillsSkillIdGetRequest {
+  skill_id: string;
+  custom_llm_provider?: string;
+}
+export const GetSkillV1SkillsSkillIdGetRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    skill_id: S.String.pipe(T.Label()),
+    custom_llm_provider: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/v1/skills/{skill_id}", code: 200 })),
+).annotate({
+  identifier: "GetSkillV1SkillsSkillIdGetRequest",
+}) as any as S.Schema<GetSkillV1SkillsSkillIdGetRequest>;
+
+export interface ListSkillsV1SkillsGetRequest {
+  limit?: number;
+  after_id?: string;
+  before_id?: string;
+  custom_llm_provider?: string;
+}
+export const ListSkillsV1SkillsGetRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    limit: S.optional(S.Number.pipe(T.Query())),
+    after_id: S.optional(S.String.pipe(T.Query())),
+    before_id: S.optional(S.String.pipe(T.Query())),
+    custom_llm_provider: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/v1/skills", code: 200 })),
+).annotate({
+  identifier: "ListSkillsV1SkillsGetRequest",
+}) as any as S.Schema<ListSkillsV1SkillsGetRequest>;
+
+export type ListSkillsResponseDataList = Array<Skill>;
+export const ListSkillsResponseDataList = /*@__PURE__*/ S.Array(
+  Skill,
+) as any as S.Schema<ListSkillsResponseDataList>;
+
+/** Response from listing skills */
+export interface ListSkillsResponse {
+  data: ListSkillsResponseDataList;
+  has_more?: boolean;
+  next_page?: string | null;
+}
+export const ListSkillsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: ListSkillsResponseDataList,
+    has_more: S.optional(S.Boolean),
+    next_page: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({
+  identifier: "ListSkillsResponse",
+}) as any as S.Schema<ListSkillsResponse>;
+
+export type CreateSkillV1SkillsPostError = UnprocessableEntity | LitellmOpError;
+/** Create Skill Create a new skill on Anthropic. Requires `?beta=true` query parameter. Model-based routing (for multi-account support): - Pass model via header: `x-litellm-model: claude-account-1` - Pass model via query: `?model=claude-account-1` - Pass model via form field: `model=claude-account-1` Example usage: ```bash # Basic usage curl -X POST "http://localhost:4000/v1/skills?beta=true" -H "Content-Type: multipart/form-data" -H "Authorization: Bearer your-key" -F "display_title=My Skill" -F "files[]=@skill.zip" # With model-based routing curl -X POST "http://localhost:4000/v1/skills?beta=true" -H "Content-Type: multipart/form-data" -H "Authorization: Bearer your-key" -H "x-litellm-model: claude-account-1" -F "display_title=My Skill" -F "files[]=@skill.zip" ``` Returns: Skill object with id, display_title, etc. */
+export const createSkillV1SkillsPost: API.OperationMethod<
+  CreateSkillV1SkillsPostRequest,
+  Skill,
+  CreateSkillV1SkillsPostError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSkillV1SkillsPostRequest,
+  output: Skill,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteSkillV1SkillsSkillIdDeleteError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Delete Skill Delete a skill by ID from Anthropic. Requires `?beta=true` query parameter. Note: Anthropic does not allow deleting skills with existing versions. Model-based routing (for multi-account support): - Pass model via header: `x-litellm-model: claude-account-1` - Pass model via query: `?model=claude-account-1` - Pass model via body: `{"model": "claude-account-1"}` Example usage: ```bash # Basic usage curl -X DELETE "http://localhost:4000/v1/skills/skill_123?beta=true" -H "Authorization: Bearer your-key" # With model-based routing curl -X DELETE "http://localhost:4000/v1/skills/skill_123?beta=true" -H "Authorization: Bearer your-key" -H "x-litellm-model: claude-account-1" ``` Returns: DeleteSkillResponse with type="skill_deleted" */
+export const deleteSkillV1SkillsSkillIdDelete: API.OperationMethod<
+  DeleteSkillV1SkillsSkillIdDeleteRequest,
+  DeleteSkillResponse,
+  DeleteSkillV1SkillsSkillIdDeleteError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteSkillV1SkillsSkillIdDeleteRequest,
+  output: DeleteSkillResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSkillV1SkillsSkillIdGetError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Get Skill Get a specific skill by ID from Anthropic. Requires `?beta=true` query parameter. Model-based routing (for multi-account support): - Pass model via header: `x-litellm-model: claude-account-1` - Pass model via query: `?model=claude-account-1` - Pass model via body: `{"model": "claude-account-1"}` Example usage: ```bash # Basic usage curl "http://localhost:4000/v1/skills/skill_123?beta=true" -H "Authorization: Bearer your-key" # With model-based routing curl "http://localhost:4000/v1/skills/skill_123?beta=true" -H "Authorization: Bearer your-key" -H "x-litellm-model: claude-account-1" ``` Returns: Skill object */
+export const getSkillV1SkillsSkillIdGet: API.OperationMethod<
+  GetSkillV1SkillsSkillIdGetRequest,
+  Skill,
+  GetSkillV1SkillsSkillIdGetError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSkillV1SkillsSkillIdGetRequest,
+  output: Skill,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSkillsV1SkillsGetError = UnprocessableEntity | LitellmOpError;
+/** List Skills List skills on Anthropic. Requires `?beta=true` query parameter. Model-based routing (for multi-account support): - Pass model via header: `x-litellm-model: claude-account-1` - Pass model via query: `?model=claude-account-1` - Pass model via body: `{"model": "claude-account-1"}` Example usage: ```bash # Basic usage curl "http://localhost:4000/v1/skills?beta=true&limit=10" -H "Authorization: Bearer your-key" # With model-based routing curl "http://localhost:4000/v1/skills?beta=true&limit=10" -H "Authorization: Bearer your-key" -H "x-litellm-model: claude-account-1" ``` Returns: ListSkillsResponse with list of skills */
+export const listSkillsV1SkillsGet: API.OperationMethod<
+  ListSkillsV1SkillsGetRequest,
+  ListSkillsResponse,
+  ListSkillsV1SkillsGetError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSkillsV1SkillsGetRequest,
+  output: ListSkillsResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));