@homeflare/distilled-litellm 0.2.0

package/src/services/cache_settings.ts

@@ -0,0 +1,234 @@
+// 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 GetCacheSettingsCacheSettingsGetRequest {}
+export const GetCacheSettingsCacheSettingsGetRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/cache/settings", code: 200 }),
+    ),
+).annotate({
+  identifier: "GetCacheSettingsCacheSettingsGetRequest",
+}) as any as S.Schema<GetCacheSettingsCacheSettingsGetRequest>;
+
+/** Current values of cache settings */
+export type CacheSettingsResponseCurrentValuesMap = {
+  [key: string]: unknown | undefined;
+};
+export const CacheSettingsResponseCurrentValuesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.Unknown,
+) as any as S.Schema<CacheSettingsResponseCurrentValuesMap>;
+
+export type CacheSettingsFieldOptionsList = Array<string>;
+export const CacheSettingsFieldOptionsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CacheSettingsFieldOptionsList>;
+
+export interface CacheSettingsField {
+  field_default?: unknown;
+  field_description: string;
+  field_name: string;
+  field_type: string;
+  field_value: unknown;
+  link?: string | null;
+  options?: CacheSettingsFieldOptionsList | null;
+  redis_type?: string | null;
+  ui_field_name: string;
+}
+export const CacheSettingsField = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    field_default: S.optional(S.Unknown),
+    field_description: S.String,
+    field_name: S.String,
+    field_type: S.String,
+    field_value: S.Unknown,
+    link: S.optional(S.NullOr(S.String)),
+    options: S.optional(S.NullOr(CacheSettingsFieldOptionsList)),
+    redis_type: S.optional(S.NullOr(S.String)),
+    ui_field_name: S.String,
+  }),
+).annotate({
+  identifier: "CacheSettingsField",
+}) as any as S.Schema<CacheSettingsField>;
+
+/** List of all configurable cache settings with metadata */
+export type CacheSettingsResponseFieldsList = Array<CacheSettingsField>;
+export const CacheSettingsResponseFieldsList = /*@__PURE__*/ S.Array(
+  CacheSettingsField,
+) as any as S.Schema<CacheSettingsResponseFieldsList>;
+
+/** Descriptions for each Redis type option */
+export type CacheSettingsResponseRedisTypeDescriptionsMap = {
+  [key: string]: string | undefined;
+};
+export const CacheSettingsResponseRedisTypeDescriptionsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.String,
+  ) as any as S.Schema<CacheSettingsResponseRedisTypeDescriptionsMap>;
+
+export interface CacheSettingsResponse {
+  /** Current values of cache settings */
+  current_values: CacheSettingsResponseCurrentValuesMap;
+  /** List of all configurable cache settings with metadata */
+  fields: CacheSettingsResponseFieldsList;
+  /** Descriptions for each Redis type option */
+  redis_type_descriptions: CacheSettingsResponseRedisTypeDescriptionsMap;
+}
+export const CacheSettingsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    current_values: CacheSettingsResponseCurrentValuesMap,
+    fields: CacheSettingsResponseFieldsList,
+    redis_type_descriptions: CacheSettingsResponseRedisTypeDescriptionsMap,
+  }),
+).annotate({
+  identifier: "CacheSettingsResponse",
+}) as any as S.Schema<CacheSettingsResponse>;
+
+/** Cache settings to test connection with */
+export type PostTestCacheConnectionCacheSettingsTestRequestCacheSettingsMap = {
+  [key: string]: unknown | undefined;
+};
+export const PostTestCacheConnectionCacheSettingsTestRequestCacheSettingsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as S.Schema<PostTestCacheConnectionCacheSettingsTestRequestCacheSettingsMap>;
+
+export interface PostTestCacheConnectionCacheSettingsTestRequest {
+  /** Cache settings to test connection with */
+  cache_settings: PostTestCacheConnectionCacheSettingsTestRequestCacheSettingsMap;
+}
+export const PostTestCacheConnectionCacheSettingsTestRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      cache_settings:
+        PostTestCacheConnectionCacheSettingsTestRequestCacheSettingsMap,
+    }).pipe(T.Http({ method: "POST", uri: "/cache/settings/test", code: 200 })),
+  ).annotate({
+    identifier: "PostTestCacheConnectionCacheSettingsTestRequest",
+  }) as any as S.Schema<PostTestCacheConnectionCacheSettingsTestRequest>;
+
+export interface CacheTestResponse {
+  /** Error message if connection failed */
+  error?: string | null;
+  /** Connection result message */
+  message: string;
+  /** Connection status: 'success' or 'failed' */
+  status: string;
+}
+export const CacheTestResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    error: S.optional(S.NullOr(S.String)),
+    message: S.String,
+    status: S.String,
+  }),
+).annotate({
+  identifier: "CacheTestResponse",
+}) as any as S.Schema<CacheTestResponse>;
+
+/** Cache settings to save */
+export type UpdateCacheSettingsCacheSettingsPostRequestCacheSettingsMap = {
+  [key: string]: unknown | undefined;
+};
+export const UpdateCacheSettingsCacheSettingsPostRequestCacheSettingsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as S.Schema<UpdateCacheSettingsCacheSettingsPostRequestCacheSettingsMap>;
+
+export interface UpdateCacheSettingsCacheSettingsPostRequest {
+  /** Cache settings to save */
+  cache_settings: UpdateCacheSettingsCacheSettingsPostRequestCacheSettingsMap;
+}
+export const UpdateCacheSettingsCacheSettingsPostRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      cache_settings:
+        UpdateCacheSettingsCacheSettingsPostRequestCacheSettingsMap,
+    }).pipe(T.Http({ method: "POST", uri: "/cache/settings", code: 200 })),
+  ).annotate({
+    identifier: "UpdateCacheSettingsCacheSettingsPostRequest",
+  }) as any as S.Schema<UpdateCacheSettingsCacheSettingsPostRequest>;
+
+export interface UpdateCacheSettingsCacheSettingsPostResponse {
+  body: unknown;
+}
+export const UpdateCacheSettingsCacheSettingsPostResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+  ).annotate({
+    identifier: "UpdateCacheSettingsCacheSettingsPostResponse",
+  }) as any as S.Schema<UpdateCacheSettingsCacheSettingsPostResponse>;
+
+export type GetCacheSettingsCacheSettingsGetError = LitellmOpError;
+/** Get Cache Settings Get cache configuration and available settings. Returns: - fields: List of all configurable cache settings with their metadata (type, description, default, options) - current_values: Current values of cache settings from database */
+export const getCacheSettingsCacheSettingsGet: API.OperationMethod<
+  GetCacheSettingsCacheSettingsGetRequest,
+  CacheSettingsResponse,
+  GetCacheSettingsCacheSettingsGetError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCacheSettingsCacheSettingsGetRequest,
+  output: CacheSettingsResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostTestCacheConnectionCacheSettingsTestError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Test Cache Connection Test cache connection with provided credentials. Creates a temporary cache instance and uses its test_connection method to verify the credentials work without affecting global state. */
+export const postTestCacheConnectionCacheSettingsTest: API.OperationMethod<
+  PostTestCacheConnectionCacheSettingsTestRequest,
+  CacheTestResponse,
+  PostTestCacheConnectionCacheSettingsTestError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostTestCacheConnectionCacheSettingsTestRequest,
+  output: CacheTestResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateCacheSettingsCacheSettingsPostError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Update Cache Settings Save cache settings to database and initialize cache. This endpoint: 1. Encrypts sensitive fields (passwords, etc.) 2. Saves to LiteLLM_CacheConfig table 3. Reinitializes cache with new settings */
+export const updateCacheSettingsCacheSettingsPost: API.OperationMethod<
+  UpdateCacheSettingsCacheSettingsPostRequest,
+  UpdateCacheSettingsCacheSettingsPostResponse,
+  UpdateCacheSettingsCacheSettingsPostError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateCacheSettingsCacheSettingsPostRequest,
+  output: UpdateCacheSettingsCacheSettingsPostResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/caching.ts

@@ -0,0 +1,175 @@
+// 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 CacheDeleteCacheDeletePostRequest {}
+export const CacheDeleteCacheDeletePostRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "POST", uri: "/cache/delete", code: 200 }),
+  ),
+).annotate({
+  identifier: "CacheDeleteCacheDeletePostRequest",
+}) as any as S.Schema<CacheDeleteCacheDeletePostRequest>;
+
+export interface CacheDeleteCacheDeletePostResponse {
+  body: unknown;
+}
+export const CacheDeleteCacheDeletePostResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.Unknown,
+  }),
+).annotate({
+  identifier: "CacheDeleteCacheDeletePostResponse",
+}) as any as S.Schema<CacheDeleteCacheDeletePostResponse>;
+
+export interface GetCachePingCachePingRequest {}
+export const GetCachePingCachePingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/cache/ping", code: 200 })),
+).annotate({
+  identifier: "GetCachePingCachePingRequest",
+}) as any as S.Schema<GetCachePingCachePingRequest>;
+
+export type CachePingResponseHealthCheckCacheParamsMap = {
+  [key: string]: unknown | undefined;
+};
+export const CachePingResponseHealthCheckCacheParamsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Unknown,
+  ) as any as S.Schema<CachePingResponseHealthCheckCacheParamsMap>;
+
+export interface CachePingResponse {
+  cache_type: string;
+  health_check_cache_params?: CachePingResponseHealthCheckCacheParamsMap | null;
+  litellm_cache_params?: string | null;
+  ping_response?: boolean | null;
+  set_cache_response?: string | null;
+  status: string;
+}
+export const CachePingResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cache_type: S.String,
+    health_check_cache_params: S.optional(
+      S.NullOr(CachePingResponseHealthCheckCacheParamsMap),
+    ),
+    litellm_cache_params: S.optional(S.NullOr(S.String)),
+    ping_response: S.optional(S.NullOr(S.Boolean)),
+    set_cache_response: S.optional(S.NullOr(S.String)),
+    status: S.String,
+  }),
+).annotate({
+  identifier: "CachePingResponse",
+}) as any as S.Schema<CachePingResponse>;
+
+export interface GetCacheRedisInfoCacheRedisInfoRequest {}
+export const GetCacheRedisInfoCacheRedisInfoRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/cache/redis/info", code: 200 }),
+    ),
+).annotate({
+  identifier: "GetCacheRedisInfoCacheRedisInfoRequest",
+}) as any as S.Schema<GetCacheRedisInfoCacheRedisInfoRequest>;
+
+export interface GetCacheRedisInfoCacheRedisInfoResponse {
+  body: unknown;
+}
+export const GetCacheRedisInfoCacheRedisInfoResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "GetCacheRedisInfoCacheRedisInfoResponse",
+}) as any as S.Schema<GetCacheRedisInfoCacheRedisInfoResponse>;
+
+export interface PostCacheFlushallCacheFlushallRequest {}
+export const PostCacheFlushallCacheFlushallRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(
+      T.Http({ method: "POST", uri: "/cache/flushall", code: 200 }),
+    ),
+).annotate({
+  identifier: "PostCacheFlushallCacheFlushallRequest",
+}) as any as S.Schema<PostCacheFlushallCacheFlushallRequest>;
+
+export interface PostCacheFlushallCacheFlushallResponse {
+  body: unknown;
+}
+export const PostCacheFlushallCacheFlushallResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      body: S.Unknown,
+    }),
+).annotate({
+  identifier: "PostCacheFlushallCacheFlushallResponse",
+}) as any as S.Schema<PostCacheFlushallCacheFlushallResponse>;
+
+export type CacheDeleteCacheDeletePostError = LitellmOpError;
+/** Cache Delete Endpoint for deleting a key from the cache. All responses from litellm proxy have `x-litellm-cache-key` in the headers Parameters: - **keys**: *Optional[List[str]]* - A list of keys to delete from the cache. Example {"keys": ["key1", "key2"]} ```shell curl -X POST "http://0.0.0.0:4000/cache/delete" -H "Authorization: Bearer sk-1234" -d '{"keys": ["key1", "key2"]}' ``` */
+export const cacheDeleteCacheDeletePost: API.OperationMethod<
+  CacheDeleteCacheDeletePostRequest,
+  CacheDeleteCacheDeletePostResponse,
+  CacheDeleteCacheDeletePostError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CacheDeleteCacheDeletePostRequest,
+  output: CacheDeleteCacheDeletePostResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCachePingCachePingError = LitellmOpError;
+/** Cache Ping Endpoint for checking if cache can be pinged */
+export const getCachePingCachePing: API.OperationMethod<
+  GetCachePingCachePingRequest,
+  CachePingResponse,
+  GetCachePingCachePingError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCachePingCachePingRequest,
+  output: CachePingResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCacheRedisInfoCacheRedisInfoError = LitellmOpError;
+/** Cache Redis Info Endpoint for getting /redis/info */
+export const getCacheRedisInfoCacheRedisInfo: API.OperationMethod<
+  GetCacheRedisInfoCacheRedisInfoRequest,
+  GetCacheRedisInfoCacheRedisInfoResponse,
+  GetCacheRedisInfoCacheRedisInfoError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCacheRedisInfoCacheRedisInfoRequest,
+  output: GetCacheRedisInfoCacheRedisInfoResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostCacheFlushallCacheFlushallError = LitellmOpError;
+/** Cache Flushall A function to flush all items from the cache. (All items will be deleted from the cache with this) Raises HTTPException if the cache is not initialized or if the cache type does not support flushing. Returns a dictionary with the status of the operation. Usage: ``` curl -X POST http://0.0.0.0:4000/cache/flushall -H "Authorization: Bearer sk-1234" ``` */
+export const postCacheFlushallCacheFlushall: API.OperationMethod<
+  PostCacheFlushallCacheFlushallRequest,
+  PostCacheFlushallCacheFlushallResponse,
+  PostCacheFlushallCacheFlushallError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostCacheFlushallCacheFlushallRequest,
+  output: PostCacheFlushallCacheFlushallResponse,
+  errors: [],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));