@homeflare/alchemy 0.43.0 → 0.45.0

package/dist/litellm/credential-values.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The values of a `LiteLLM.Credential` — resolved from the deploying process's environment at
+ * call time, held as `Redacted`, and compared by seal.
+ *
+ * ★ THIS IS THE CREDENTIAL LITELLM STORES, so the deploying process holds the value: the wire
+ *   body carries the LITERAL (the proxy encrypts it into its database, measured in the live
+ *   1.103.0 container — `credential_endpoints/endpoints.py`'s `encrypt_credential_values`), which
+ *   is exactly why the prop is only a NAME (`credential-types.ts`). Inside this process the value
+ *   is a `Redacted<string>`, so a stray log or error dump prints `<redacted>`; it is unwrapped in
+ *   exactly one place, the wire body (credential-form.ts). Never a prop or an attribute.
+ * ⚠️ LITELLM DOES NOT HAND THE VALUES BACK TO COMPARE WITH: both reads answer them MASKED
+ *   (2 + `****` + 2, `*****` for a short string — `litellm_logging.py::_get_masked_values`), and a
+ *   masked fragment is a partial secret that must never be compared or stored. So what was last
+ *   written is remembered as a SEAL, and a plan asks "are the values in my environment the ones I
+ *   wrote". Four answers, mcp-server-credential.ts's own list:
+ *   - `none`    — no values are declared, nothing to compare.
+ *   - `unknown` — one or more declared variables is unset here, so a plan cannot tell. Never
+ *                 drift: a plan-only environment must not report every credentialed row as
+ *                 changed. A WRITE still demands them (`requireValues`).
+ *   - `stale`   — every variable is set and there is no seal (an adopted row, or one written
+ *                 outside this stack) or the seal disagrees. The declaration is authoritative,
+ *                 so it is written.
+ *   - `match`   — the seal was made from exactly these resolved values.
+ * ⚠️ ALL-OR-NOTHING RESOLUTION: a write sends `credential_values` only when EVERY declared
+ *   variable resolves — the values-stale PATCH and the whole-row create both demand every value
+ *   (`requireValues`, credential.ts), because sending the resolved half would store a row whose
+ *   unset half was silently blanked. When any variable is missing the state is `unknown`: an
+ *   info-only PATCH can proceed, but a required rewrite refuses before DELETE.
+ * ⚠️ A SEAL OF A GUESSABLE SECRET IS STILL GUESSABLE (secrets/write-only.ts). Use a random token.
+ */
+import * as Effect from 'effect/Effect';
+import * as Redacted from 'effect/Redacted';
+import { type Environment } from '../secrets/write-only.ts';
+import { LitellmCredentialEnvUnsetError } from './credential-errors.ts';
+import type { CredentialProps } from './credential-types.ts';
+/** What the environment holds for the declared values. `missing` names the unset variables. */
+export interface ResolvedValues {
+    readonly values: Readonly<Record<string, Redacted.Redacted<string>>>;
+    readonly missing: readonly string[];
+}
+export type CredentialValuesState = 'none' | 'unknown' | 'stale' | 'match';
+/** ⛔ Reads the environment at CALL time, never at module load (docs/credentials.md). */
+export declare const resolveValues: (props: CredentialProps, env?: Environment) => ResolvedValues;
+/** `scrypt:<salt>:<digest>` of the resolved values, for `valuesSeal`. ⛔ Never a value. */
+export declare const sealValues: (values: Readonly<Record<string, Redacted.Redacted<string>>>) => string;
+export declare const valuesState: (props: CredentialProps, sealed: string, resolved?: ResolvedValues) => CredentialValuesState;
+/**
+ * Fails naming the missing variables when this write has to send the values and the deploying
+ * process does not hold them all. Creates, rewrites and value-stale PATCHes need every value;
+ * an info-only PATCH leaves values alone and does not need this guard (credential.ts).
+ */
+export declare const requireValues: (props: CredentialProps, resolved: ResolvedValues) => Effect.Effect<void, LitellmCredentialEnvUnsetError>;
+//# sourceMappingURL=credential-values.d.ts.map

package/dist/litellm/credential-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-values.d.ts","sourceRoot":"","sources":["../../src/litellm/credential-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,KAAK,WAAW,EAAiC,MAAM,0BAA0B,CAAC;AAC3F,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,+FAA+F;AAC/F,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACrE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAE3E,wFAAwF;AACxF,eAAO,MAAM,aAAa,UACjB,eAAe,QACjB,WAAW,KACf,cAQF,CAAC;AAKF,0FAA0F;AAC1F,eAAO,MAAM,UAAU,WAAY,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAG,MACjE,CAAC;AAEzB,eAAO,MAAM,WAAW,UACf,eAAe,UACd,MAAM,aACJ,cAAc,KACvB,qBAMF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,UACjB,eAAe,YACZ,cAAc,KACvB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,8BAA8B,CAQ9C,CAAC"}

package/dist/litellm/credential.d.ts

@@ -0,0 +1,83 @@
+/**
+ * `LiteLLM.Credential` — one row of LiteLLM's reusable credential table (`/credentials/*`), a
+ * named bag of values the proxy stores encrypted and can bind to a deployment by `model_id`.
+ *
+ * ★ ADOPT BY NAME. `credentialName` finds the live row whose `credential_name` equals it; a live
+ *   row with no state is `Unowned`, so it needs `--adopt`. The name is the vendor's only address
+ *   (the table's unique column, `schema.prisma`), so a row is located by the by-name read and
+ *   never guessed at.
+ * ★ `defaultRemovalPolicy: 'retain'` — deleting a credential a deployment references would break
+ *   that deployment's next call. Opt in with `.pipe(RemovalPolicy.destroy())`.
+ * ⛔ THE VALUES ARE `{ fromEnv: 'NAME' }`, NEVER A VALUE (S25): LiteLLM STORES these literals
+ *   (encrypted at rest), so the deploying process must hold them — credential-types.ts carries the
+ *   full reasoning, and a `model` deployment's `os.environ/NAME` reference is the opposite case.
+ *   A plan compares the live row's `credential_info` per declared key and the values through a
+ *   digest of what was resolved (`valuesSeal`); it never compares the masked read, and a value
+ *   whose variable is unset never drifts a plan-only environment (credential-values.ts).
+ * ⚠️ A RENAME IS A REPLACE: the name is the row's identity and its only address, so a changed
+ *   `credentialName` creates the new row and the old one survives under 'retain' — never renamed
+ *   in place.
+ * ⚠️ A CHANGED ROW IS PATCHED, NOT REWRITTEN — PATCH merges values and normally replaces DB
+ *   info, but only merges in-memory info (1.103.0 credential_endpoints/endpoints.py:312-319,384-387).
+ *   A failed PATCH leaves the row behind (review finding 3: DELETE + POST left NO row when POST
+ *   failed). Dropping a value key OR an info key still requires DELETE + POST; both stores must
+ *   converge. All refusals run before the first write. Every write reads back to prove removal.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import { LitellmCredentialAbsentAfterWriteError, LitellmCredentialInvalidError, LitellmCredentialNotConvergedError } from './credential-errors.ts';
+import type { CredentialAttributes, CredentialProps } from './credential-types.ts';
+export type { CredentialAttributes, CredentialProps };
+export type { CredentialError } from './credential-errors.ts';
+export interface LiteLLMCredential extends Resource<'LiteLLM.Credential', CredentialProps, CredentialAttributes> {
+}
+export declare const LiteLLMCredential: import("alchemy").ResourceClass<LiteLLMCredential>;
+export declare const isLiteLLMCredential: (value: unknown) => value is LiteLLMCredential;
+type Args<P> = {
+    fqn: string;
+    instanceId: string;
+    output: CredentialAttributes | undefined;
+} & P;
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export declare const credentialHandlers: {
+    /**
+     * ⛔ WITH NO `output` THIS IS ALCHEMY'S ADOPTION PROBE, AND THE ONLY PLAN-TIME HOOK A NEW
+     *   CREDENTIAL GETS — so the refusals run here too, as a defect (mcp-server.ts's own rule: the
+     *   cold-start probe must fail the plan, and a recovery read must degrade to "nothing
+     *   recovered", which only a defect does).
+     */
+    read: ({ olds, output }: Args<{
+        olds: CredentialProps;
+    }>) => Effect.Effect<CredentialAttributes | undefined, import("./credential-errors.ts").LitellmCredentialDebugLoggingError | import("./credential-errors.ts").LitellmCredentialUnreadableError | import("@distilled.cloud/litellm/credential_management").GetCredentialByNameCredentialsByNameCredentialNameGetError, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    diff: ({ news, output, }: {
+        news: Input<CredentialProps>;
+        output: CredentialAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'replace';
+        readonly deleteFirst: false;
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'noop';
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'update';
+    } | undefined, LitellmCredentialInvalidError, never>;
+    reconcile: ({ fqn, instanceId, news, output }: Args<{
+        news: CredentialProps;
+    }>) => Effect.Effect<{
+        credentialName: string;
+        credentialInfo: Readonly<Record<string, unknown>>;
+        valueKeys?: readonly string[];
+        infoKeys?: readonly string[];
+        valuesSeal: string;
+    }, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/litellm/credential_management").CredentialNotFound | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | LitellmCredentialAbsentAfterWriteError | import("./credential-errors.ts").LitellmCredentialDebugLoggingError | import("./credential-errors.ts").LitellmCredentialEnvUnsetError | LitellmCredentialInvalidError | LitellmCredentialNotConvergedError | import("./credential-errors.ts").LitellmCredentialRewriteError | import("./credential-errors.ts").LitellmCredentialTransportError | import("./credential-errors.ts").LitellmCredentialUnreadableError | import("@distilled.cloud/litellm/Errors").LitellmParseError | import("@distilled.cloud/caddy").ServiceUnavailable | import("@distilled.cloud/caddy").TooManyRequests | import("@distilled.cloud/caddy").Unauthorized | import("@distilled.cloud/litellm/Errors").UnknownLitellmError | import("@distilled.cloud/litellm/credential_management").UnprocessableEntity, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    delete: ({ output }: {
+        output: CredentialAttributes;
+    }) => Effect.Effect<void, import("@distilled.cloud/litellm/credential_management").DeleteCredentialCredentialsCredentialNameDeleteError, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    /** ⛔ EMPTY: adoption is an explicit act (`--adopt`), and no ownership mark exists to filter by. */
+    list: () => Effect.Effect<never[], never, never>;
+};
+export declare const LiteLLMCredentialProvider: () => import("effect/Layer").Layer<Provider.Provider<LiteLLMCredential>, never, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=credential.d.ts.map

package/dist/litellm/credential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential.d.ts","sourceRoot":"","sources":["../../src/litellm/credential.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EACL,sCAAsC,EACtC,6BAA6B,EAC7B,kCAAkC,EACnC,MAAM,wBAAwB,CAAC;AAiBhC,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAInF,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,WAAW,iBAAkB,SAAQ,QAAQ,CACjD,oBAAoB,EACpB,eAAe,EACf,oBAAoB,CACrB;CAAG;AAEJ,eAAO,MAAM,iBAAiB,oDAE5B,CAAC;AAEH,eAAO,MAAM,mBAAmB,UAAW,OAAO,KAAG,KAAK,IAAI,iBACe,CAAC;AAc9E,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC1C,GAAG,CAAC,CAAC;AAEN,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;IAC7B;;;;;OAKG;IACH,IAAI,qBAAqB,IAAI,CAAC;QAAE,IAAI,EAAE,eAAe,CAAA;KAAE,CAAC;IAmBxD,IAAI,sBAGD;QACD,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;QAC7B,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAAC;KAC1C;yBAOsB,SAAS;;;;yBASb,MAAM;;;yBACN,QAAQ;;IAG3B,SAAS,sCAAsC,IAAI,CAAC;QAAE,IAAI,EAAE,eAAe,CAAA;KAAE,CAAC;;;;;;;IAuE9E,MAAM,eAAe;QAAE,MAAM,EAAE,oBAAoB,CAAA;KAAE;IAErD,mGAAmG;IACnG,IAAI;CACL,CAAC;AAEF,eAAO,MAAM,yBAAyB,+IAInC,CAAC"}

package/dist/litellm/fake-access-group-litellm.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A fake of LiteLLM's `/v1/unified_access_group` routes for tests — TEST ONLY. Skeleton and the
+ * rules every fake follows: fake-registry-base.ts.
+ *
+ * ★ MEASURED FROM THE LIVE 1.103.0 CONTAINER'S SOURCE (2026-09-30, `access_group_endpoints.py`, read,
+ *   not called): the name is UNIQUE (a create or a rename onto a taken name is a 409); a create
+ *   answers 201 with the row; the update is partial (`exclude_unset`) and turns a `null` list into
+ *   `[]`; a delete answers 204 with NO BODY and a missing id is a 404; writes need PROXY_ADMIN
+ *   (`forbidWrites` models the 403). The list is the table.
+ * ⚠️ NOT MODELLED: `assigned_team_ids` / `assigned_key_ids` mirroring into teams and keys (the fake
+ *   keeps the arrays and does nothing with them), and the display-name expansion of the response.
+ *   `dropModel` models `access_group_model_sync.py`: LiteLLM itself removes a model name from a group
+ *   when its last deployment goes, which is the drift source the docs warn about.
+ */
+import { type FakeRecord } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+export interface FakeAccessGroupLitellm extends FakeRecord {
+    /** Every stored group, exactly as the proxy holds it. */
+    readonly groups: () => readonly Row[];
+    /** LiteLLM's own model-name pruning (`access_group_model_sync.py`). */
+    readonly dropModel: (name: string) => void;
+}
+export interface FakeAccessGroupOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** `POST`/`PUT`/`DELETE` answer 403, as for a key that is not PROXY_ADMIN. */
+    readonly forbidWrites?: boolean;
+    /** A `PUT` drops empty lists instead of writing them (a truthiness check). */
+    readonly editIgnoresEmpty?: boolean;
+}
+/** A row as `AccessGroupResponse` carries it: every required field present. */
+export declare const groupRow: (fields: Row) => Row;
+export declare const startFakeAccessGroupLitellm: (options?: FakeAccessGroupOptions) => FakeAccessGroupLitellm;
+//# sourceMappingURL=fake-access-group-litellm.d.ts.map

package/dist/litellm/fake-access-group-litellm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-access-group-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-access-group-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAY,KAAK,UAAU,EAA+B,MAAM,yBAAyB,CAAC;AACjG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,WAAW,sBAAuB,SAAQ,UAAU;IACxD,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACtC,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,+EAA+E;AAC/E,eAAO,MAAM,QAAQ,WAAY,GAAG,KAAG,GAcrC,CAAC;AAEH,eAAO,MAAM,2BAA2B,aAC7B,sBAAsB,KAC9B,sBA0EF,CAAC"}

package/dist/litellm/fake-credential-litellm.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A fake of LiteLLM's `/credentials/*` routes for tests — TEST ONLY, never imported by `index.ts`.
+ * Like `fake-model-litellm.ts` it is a `fetch` function handed to Effect's real `FetchHttpClient`
+ * through its `Fetch` reference, so a test exercises distilled's REAL path assembly, JSON encoding
+ * and status-to-error matching; only the wire responses a scenario needs are written here.
+ *
+ * ★ THE MASKING RULE IS THE VENDOR'S, READ FROM THE LIVE 1.103.0 CONTAINER
+ *   (`litellm_logging.py::_get_masked_values`): a key whose lowercased form contains `token`,
+ *   `key`, `secret`, `password`, `passwd`, `credentials`, `vertex_credentials` or
+ *   `authorization` answers `v[:2] + "****" + v[-2:]` for a string longer than four characters,
+ *   `*****` for a shorter one, the value untouched for a non-string, and a non-sensitive key
+ *   answers its full value. Both the list and the by-name read apply it (the by-name read with
+ *   `unmasked_length=4, number_of_asterisks=4` — the same rule).
+ * ★ THE READ AND THE DELETE ASK DIFFERENT STORES, AS THE VENDOR DOES (measured): the by-name read
+ *   answers only rows loaded in memory, while the delete consults the table. `memoryOmits` models
+ *   a row committed to the table but not loaded in memory, so the read answers 404 while the
+ *   create for the same name answers 409 — the asymmetry credential-operations.ts documents.
+ * ★ A CREATE ON AN EXISTING NAME ANSWERS 409 (the vendor's unique-violation handling,
+ *   `_credential_exists_detail`), decoded by the real SDK path as core `Conflict`. The PATCH route
+ *   merges values in both stores; nonempty info normally replaces DB info but merges in memory
+ *   (`credential_endpoints/endpoints.py:312-319,384-387`, 1.103.0). Empty info leaves DB unchanged. With
+ *   the body's `credential_name` (the `credential_name_body` member) applied as the new name only
+ *   when it differs from the path's (the kit never renames in place, so it never does).
+ * ★ `FAKE-*` VALUES ONLY. Nothing here is, or looks like, a real credential.
+ */
+/** One request that reached the fake. Its own type, so this file depends on no other fake. */
+export interface FakeCredentialRequest {
+    readonly method: string;
+    readonly path: string;
+}
+type Row = Record<string, unknown>;
+export interface FakeCredentialLitellm {
+    readonly fetch: typeof globalThis.fetch;
+    /**
+     * Every stored row as the fake's table holds it — values in CLEAR, the fake's own choice: the
+     * real table encrypts them, but nothing reads the table directly, only the masked reads, so the
+     * encryption seam is invisible here and a test can assert what a write SENT.
+     */
+    readonly rows: () => readonly Row[];
+    readonly requests: () => readonly FakeCredentialRequest[];
+    /** The JSON bodies of every `POST` and `PATCH`, in order (including rejected PATCH requests). */
+    readonly bodies: () => readonly Row[];
+}
+export interface FakeCredentialOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** Names committed to the table that the in-memory read omits (a row not loaded). */
+    readonly memoryOmits?: readonly string[];
+}
+/** A minimal 1.103.0-shaped row, as the table holds it. */
+export declare const credentialRow: (fields: Row) => Row;
+export declare const startFakeCredentialLitellm: (options?: FakeCredentialOptions) => FakeCredentialLitellm;
+export {};
+//# sourceMappingURL=fake-credential-litellm.d.ts.map

package/dist/litellm/fake-credential-litellm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-credential-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-credential-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,8FAA8F;AAC9F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,qBAAqB,EAAE,CAAC;IAC1D,iGAAiG;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,qFAAqF;IACrF,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAKD,2DAA2D;AAC3D,eAAO,MAAM,aAAa,WAAY,GAAG,KAAG,GAK1C,CAAC;AAgCH,eAAO,MAAM,0BAA0B,aAC5B,qBAAqB,KAC7B,qBAuHF,CAAC"}

package/dist/litellm/fake-keys.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A fake of LiteLLM's `/key/*` routes for `LiteLLM.Key` tests — TEST ONLY, never imported by
+ * `index.ts`. `fake-litellm.ts` mounts it, so a test still goes through distilled's REAL path
+ * assembly, JSON encode/decode and status→typed-error matching over `FetchHttpClient.Fetch`.
+ *
+ * ★ MEASURED against the litellm 1.103.0 wheel's source (`key_management_endpoints.py`), not a live
+ *   proxy: a user-defined `key` must start with `sk-` and be 16+ characters, else 400 (:1477-1490); a
+ *   duplicate `key_alias` is 400 on generate and update (`_enforce_unique_key_alias`, :7639-7667);
+ *   `/key/update` applies `model_dump(exclude_unset=True)`, so an explicit `null` clears a column
+ *   (`duration: null` sets `expires` null, :2468-2500) and omitted fields are untouched; an update
+ *   that finds no alias is 404 (`_get_and_validate_existing_key`, per the distilled patch); a delete
+ *   of an alias it does not hold is 404 "No keys found" (:4914-4918) and of a key the caller may not
+ *   delete 403 (:4933-4936), BOTH answered as a `ProxyException` envelope, because `delete_key_fn`
+ *   re-raises through `handle_exception_on_proxy` (`proxy/utils.py:7815`), whose `message` is `str(detail)`
+ *   (`_types.py` `ProxyException`): `{"error": {"message": "{'error': 'No keys found'}", "code": "404", ...}}`;
+ *   `/key/list` filters `key_alias` exactly unless told otherwise, and
+ *   `return_full_object` answers full rows, `token` being the sha256 hex of the key (`hash_token`).
+ * ⚠️ NOT MODELLED, or only a stand-in: `disable_custom_api_keys` (a 403 for ANY user-defined key);
+ *   a `budget_id` that names no budget is a foreign-key violation whose status is UNMEASURED — 400
+ *   here, so a test can prove the Budget is written first.
+ * ⛔ THE PLAINTEXT KEY NEVER SITS IN A ROW. Rows carry only `token`, a sha256 of the value, the way
+ *   a LiteLLM row carries a hash. The values the proxy was SENT are kept apart in `received()`, so a
+ *   test can prove what reached the wire without the value ever being in the state a resource sees.
+ */
+type Row = Record<string, unknown>;
+export interface FakeKeysOptions {
+    /** Live rows, wire-shaped like `UserAPIKeyAuth` (`key_alias`, `budget_id`, `models`, `token`, …). */
+    readonly keySeed?: readonly Row[];
+    /** `GET /key/list` answers this status and nothing else — a transient read failure. */
+    readonly keyListStatus?: number;
+    /** `POST /key/delete` answers 403 and keeps the row — a caller that may not delete. */
+    readonly keyDeleteForbidden?: boolean;
+    /** `POST /key/delete` deletes the row and STILL answers 404 — another caller got there first. */
+    readonly keyDeleteRaces?: boolean;
+    /** `/key/generate` ignores the user-defined `key` and mints its own. */
+    readonly keyIgnoresUserValue?: boolean;
+    /** `/key/update` drops explicit `null`s instead of writing them (an `exclude_none` merge). */
+    readonly keyUpdateIgnoresNull?: boolean;
+}
+export interface FakeKeys {
+    readonly route: (request: Request, url: URL) => Promise<Response>;
+    readonly rows: () => readonly Row[];
+    /** Every JSON body a `/key/*` write carried, in order. FAKE-* material only. */
+    readonly writes: () => readonly {
+        readonly path: string;
+        readonly body: Row;
+    }[];
+    /** The raw key values `/key/generate` was sent — kept off the rows on purpose. */
+    readonly received: () => readonly string[];
+}
+export declare const createFakeKeys: (options: FakeKeysOptions | undefined, budgetExists: (budgetId: string) => boolean) => FakeKeys;
+export {};
+//# sourceMappingURL=fake-keys.d.ts.map

package/dist/litellm/fake-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-keys.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC,MAAM,WAAW,eAAe;IAC9B,qGAAqG;IACrG,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAClC,uFAAuF;IACvF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,uFAAuF;IACvF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IACtC,iGAAiG;IACjG,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,wEAAwE;IACxE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC,8FAA8F;IAC9F,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACpC,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;KAAE,EAAE,CAAC;IAChF,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;CAC5C;AAmCD,eAAO,MAAM,cAAc,YAChB,eAAe,GAAG,SAAS,gBACtB,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,KAC1C,QAuGF,CAAC"}

package/dist/litellm/fake-litellm.d.ts

@@ -27,6 +27,7 @@
  *   fake now matches that measured vendor behaviour.
  */
 import type { PassThroughGenericEndpoint } from '@distilled.cloud/litellm/misc';
+import { type FakeKeys, type FakeKeysOptions } from './fake-keys.ts';
 /** RFC 2606 placeholder — never a real host. Shared across tests, like `../netbox/fake-netbox.ts`. */
 export declare const FAKE_BASE = "https://litellm.example.com";
 export interface FakeRequest {
@@ -39,6 +40,8 @@ export interface FakeLitellm {
     readonly requests: () => readonly FakeRequest[];
     /** `/budget/*` rows, wire-shaped (`tpm_limit`/`rpm_limit` as decimal strings, like the real table). */
     readonly budgets: () => readonly Record<string, unknown>[];
+    /** `/key/*` rows and the writes they took — see fake-keys.ts. */
+    readonly keys: FakeKeys;
 }
 export declare const startFakeLitellm: (options?: {
     readonly masterKey?: string;
@@ -48,5 +51,5 @@ export declare const startFakeLitellm: (options?: {
     readonly budgetSeed?: readonly Record<string, unknown>[];
     /** `/budget/update` drops `null`s instead of writing them (an `exclude_none` merge). */
     readonly budgetExcludeNone?: boolean;
-}) => FakeLitellm;
+} & FakeKeysOptions) => FakeLitellm;
 //# sourceMappingURL=fake-litellm.d.ts.map

package/dist/litellm/fake-litellm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fake-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAEhF,sGAAsG;AACtG,eAAO,MAAM,SAAS,gCAAgC,CAAC;AAEvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,0BAA0B,EAAE,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IAChD,uGAAuG;IACvG,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CAC5D;AAQD,eAAO,MAAM,gBAAgB,aAAc;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IACtD,qGAAqG;IACrG,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACzD,wFAAwF;IACxF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC,KAAG,WA6GH,CAAC"}
+{"version":3,"file":"fake-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAkB,MAAM,gBAAgB,CAAC;AAErF,sGAAsG;AACtG,eAAO,MAAM,SAAS,gCAAgC,CAAC;AAEvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,0BAA0B,EAAE,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IAChD,uGAAuG;IACvG,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC3D,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AAQD,eAAO,MAAM,gBAAgB,aACjB;IACR,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IACtD,qGAAqG;IACrG,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACzD,wFAAwF;IACxF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC,GAAG,eAAe,KAClB,WAkHF,CAAC"}

package/dist/litellm/fake-mcp-litellm.d.ts

@@ -0,0 +1,67 @@
+/**
+ * A fake of LiteLLM's `/v1/mcp/server` routes for tests — TEST ONLY, never imported by `index.ts`.
+ * Like `fake-litellm.ts` it is a `fetch` function handed to Effect's real `FetchHttpClient` through
+ * its `Fetch` reference, so a test exercises distilled's REAL path assembly, JSON encoding and
+ * status-to-error matching; only the wire responses a scenario needs are written here.
+ *
+ * ★ A SEPARATE FILE FROM `fake-litellm.ts` ON PURPOSE: that fake carries the pass-through and
+ *   budget routes and is at its size budget; a fake per route family keeps each one small.
+ * ⚠️ SHAPES ARE FROM THE GENERATED 1.103.0 SCHEMA (`mcp_management.ts`), NOT A LIVE READ. What the
+ *   real proxy does on a duplicate create, an edit of a missing id, a delete of a missing id, and
+ *   whether its list redacts `credentials` is UNMEASURED; the answers below (400, 404, 404, redacted
+ *   unless `echoCredentials`) are the fake's own choices, and every test that leans on one says so.
+ * ★ ONE RULE IS MEASURED, NOT CHOSEN: an edit that changes `auth_type` and sends no `credentials` key
+ *   clears the stored credential (litellm 1.103.0, `db.py` lines 1013-1014, read from the live
+ *   container; every static type is its own credential class). The engine tests that rely on it are
+ *   `mcp-server-retype.test.ts`.
+ * ★ THREE MORE RULES ARE MEASURED (2026-09-29, the live 1.103.0 container, read from source and, for
+ *   the alias rule, by running its own normaliser on a body): (1) `GET /v1/mcp/server` is the
+ *   in-memory REGISTRY, not the table, so a row can be committed and not listed (`registryMisses`,
+ *   `hideCreated`); the by-id `GET` reads the table first and REGISTERS the row it finds. (2) The
+ *   list's `description` is `mcp_info.description` when that key exists, else the column. (3) A
+ *   write with a `server_name` and no `alias` defaults the alias to the name and WRITES it; `-` in
+ *   either name is a 400, and a space in an alias becomes `_`.
+ * ⚠️ `servers()` RETURNS WHAT REACHED THE PROXY, credentials included, so a test can assert what
+ *   was SENT. The list route (`GET`) is what a resource can read, and it hides them by default.
+ * ★ `FAKE-*` VALUES ONLY. Nothing here is, or looks like, a real credential.
+ */
+/** One request that reached the fake. Its own type, so this file depends on no other fake. */
+export interface FakeMcpRequest {
+    readonly method: string;
+    readonly path: string;
+}
+type Row = Record<string, unknown>;
+export interface FakeMcpLitellm {
+    readonly fetch: typeof globalThis.fetch;
+    /** Every stored row exactly as the proxy holds it, `credentials` included. */
+    readonly servers: () => readonly Row[];
+    readonly requests: () => readonly FakeMcpRequest[];
+    /** The JSON bodies of every `POST`/`PUT`, in order. */
+    readonly bodies: () => readonly Row[];
+}
+export interface FakeMcpOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** `GET` echoes the stored `credentials` instead of hiding them (a worst-case proxy). */
+    readonly echoCredentials?: boolean;
+    /** `PUT` drops an empty list and a `false`, like a truthiness check would. */
+    readonly editIgnoresFalsy?: boolean;
+    /** `POST` ignores a supplied `server_id` and issues its own. */
+    readonly issuesOwnId?: boolean;
+    /** Every `DELETE` answers 400, whether or not the row exists (no rights). */
+    readonly forbidDelete?: boolean;
+    /** Ids committed to the table that the registry does not hold (a failed reload), so the list omits them. */
+    readonly registryMisses?: readonly string[];
+    /** A `POST` commits the row but its registry refresh fails (LiteLLM only logs it). */
+    readonly hideCreated?: boolean;
+    /**
+     * The by-id `GET` answers 403, whether or not the row exists. ⚠️ Not 500: the SDK retries 5xx with
+     * backoff (`Retry.Retry`), which would take a test tens of seconds to no purpose.
+     */
+    readonly readFails?: boolean;
+}
+/** A minimal 1.103.0-shaped row, as the list route returns it. */
+export declare const serverRow: (fields: Row) => Row;
+export declare const startFakeMcpLitellm: (options?: FakeMcpOptions) => FakeMcpLitellm;
+export {};
+//# sourceMappingURL=fake-mcp-litellm.d.ts.map

package/dist/litellm/fake-mcp-litellm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-mcp-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-mcp-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8FAA8F;AAC9F,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,cAAc,EAAE,CAAC;IACnD,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,yFAAyF;IACzF,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,4GAA4G;IAC5G,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,sFAAsF;IACtF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAOD,kEAAkE;AAClE,eAAO,MAAM,SAAS,WAAY,GAAG,KAAG,GAOtC,CAAC;AA8BH,eAAO,MAAM,mBAAmB,aAAa,cAAc,KAAQ,cAwGlE,CAAC"}

package/dist/litellm/fake-model-litellm-post-update.d.ts

@@ -0,0 +1,49 @@
+/**
+ * POST /model/update handler for the fake LiteLLM proxy.
+ *
+ * Extracted from `fake-model-litellm.ts` so each file stays under the repository line cap.
+ * See that file for context on what the fake is and what is measured vs. assumed.
+ */
+import type { Row } from './fake-model-litellm.ts';
+type PostUpdateOptions = Readonly<{
+    /** `POST /model/update` drops a `false` and an empty list, like a truthiness check would. */
+    readonly editIgnoresFalsy?: boolean;
+    /**
+     * `POST /model/update` parses `litellm_params` the way v1.103.0 `updateLiteLLMParams` does:
+     * every unset field is filled with its pydantic default before the write. `None` keeps the
+     * stored value; a non-`None` default (`false` on the five flags below) overwrites it.
+     */
+    readonly fillsParamDefaults?: boolean;
+}>;
+/**
+ * v1.103.0 `updateLiteLLMParams`: an omitted field takes its pydantic default. The five flags
+ * default to `False`, not `None`. An explicit `null` stays `null` (it was set, not omitted) so a
+ * later `exclude_none` can drop it and keep the stored value.
+ */
+export declare const withOmittedFalseDefaults: (sent: Row) => Row;
+export interface PostModelUpdateResult {
+    readonly response: Response;
+    /** Merged row to write back into the table. */
+    readonly merged: Row;
+    /** Index into the original rows array that `merged` should replace. */
+    readonly at: number;
+}
+/**
+ * Handle `POST /model/update`.
+ *
+ * ⛔ v1.103.0 `update_model` REBUILDS `litellm_params`: it parses the request model
+ *   (every unset field filled with its pydantic default, `None` keeps the stored value)
+ *   and REPLACES the column, so a stored key the model does not declare is DELETED.
+ *   `editIgnoresFalsy` models a proxy that REFUSES a `false` or an empty list: the edit
+ *   never lands, so the row's current value survives. Drop the incoming falsy value
+ *   BEFORE the rebuild — filtering after erases the field and hides the dropped edit.
+ */
+export declare const handlePostModelUpdate: (args: {
+    readonly body: Row;
+    readonly rows: readonly Row[];
+    readonly rowId: (row: Row) => string;
+    readonly json: (status: number, body: unknown) => Response;
+    readonly options: PostUpdateOptions;
+}) => PostModelUpdateResult;
+export {};
+//# sourceMappingURL=fake-model-litellm-post-update.d.ts.map

package/dist/litellm/fake-model-litellm-post-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-model-litellm-post-update.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-model-litellm-post-update.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,KAAK,iBAAiB,GAAG,QAAQ,CAAC;IAChC,6FAA6F;IAC7F,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC,CAAC;AAkBH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,SAAU,GAAG,KAAG,GAMpD,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IACrB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,SAAU;IAC1C,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,QAAQ,CAAC;IAC3D,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACrC,KAAG,qBA8BH,CAAC"}

package/dist/litellm/fake-model-litellm.d.ts

@@ -0,0 +1,48 @@
+/** One request that reached the fake. Its own type, so this file depends on no other fake. */
+export interface FakeModelRequest {
+    readonly method: string;
+    readonly path: string;
+}
+export type Row = Record<string, unknown>;
+export interface FakeModelLitellm {
+    readonly fetch: typeof globalThis.fetch;
+    /** Every stored row exactly as the proxy holds it, `litellm_params` included. */
+    readonly models: () => readonly Row[];
+    readonly requests: () => readonly FakeModelRequest[];
+    /** The JSON bodies of every `POST`, in order. */
+    readonly bodies: () => readonly Row[];
+    /**
+     * The next `count` successful `POST /model/new` calls each make the following `GET /model/info`
+     * answer 500 once — a read-back that fails after the row is committed.
+     */
+    readonly failNextReadBacks: (count: number) => void;
+}
+export interface FakeModelOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** `POST /model/new` ignores the supplied `model_info.id` and issues its own. */
+    readonly issuesOwnId?: boolean;
+    /** Every `POST /model/delete` answers 400, whether or not the row exists (no rights). */
+    readonly forbidDelete?: boolean;
+    /**
+     * Every by-id `GET /model/info` answers 400 even when the row is listed. Models "no rights" /
+     * a bad filter: a 400 is absence only when a re-list also lacks the id (model-operations.ts).
+     */
+    readonly byIdRefused?: boolean;
+    /** `POST /model/update` drops a `false` and an empty list, like a truthiness check would. */
+    readonly editIgnoresFalsy?: boolean;
+    /**
+     * `POST /model/update` and `PATCH /model/{id}/update` parse `litellm_params` the way v1.103.0
+     * `updateLiteLLMParams` does: every unset field is filled with its pydantic default before the
+     * write. `None` keeps the stored value; a non-`None` default (`false` on the five flags) overwrites
+     * it. POST then REPLACES the column. PATCH merges after `exclude_none`, so an explicit JSON `null`
+     * is dropped and the stored value survives, while an omitted flag is written `false`.
+     */
+    readonly fillsParamDefaults?: boolean;
+    /** Ids committed to the table that the list omits; the by-id read still answers them. */
+    readonly listOmits?: readonly string[];
+}
+/** A minimal 1.103.0-shaped row, as the table holds it: the id lives in `model_info`. */
+export declare const modelRow: (fields: Row) => Row;
+export declare const startFakeModelLitellm: (options?: FakeModelOptions) => FakeModelLitellm;
+//# sourceMappingURL=fake-model-litellm.d.ts.map

package/dist/litellm/fake-model-litellm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-model-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-model-litellm.ts"],"names":[],"mappings":"AA6BA,8FAA8F;AAC9F,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,gBAAgB,EAAE,CAAC;IACrD,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,yFAAyF;IACzF,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,6FAA6F;IAC7F,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IACtC,yFAAyF;IACzF,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAOD,yFAAyF;AACzF,eAAO,MAAM,QAAQ,WAAY,GAAG,KAAG,GAKrC,CAAC;AAQH,eAAO,MAAM,qBAAqB,aAAa,gBAAgB,KAAQ,gBAwItE,CAAC"}

package/dist/litellm/fake-policy-attachment-litellm.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A fake of LiteLLM's `/policies/attachments` routes for tests — TEST ONLY. Skeleton and the rules
+ * every fake follows: fake-registry-base.ts.
+ *
+ * ★ MEASURED FROM THE LIVE 1.103.0 CONTAINER'S SOURCE (2026-09-30, `policy_endpoints.py` and
+ *   `attachment_registry.py`, read, not called): a create needs the policy to have a PRODUCTION version
+ *   (404 otherwise), refuses a CONCRETE team, key or model selector that resolves to nothing (400;
+ *   wildcards are let through), and answers the row with a proxy-issued id; the list merges in config.yaml
+ *   attachments (`definition_location: "config"`, ids `config-<n>`); a delete of a missing id is a 404.
+ *   There is NO update route, and the fake answers 405 to one so a resource that tried would fail.
+ * ⚠️ NOT MODELLED: the in-memory registry and how a request is matched (`policy_matcher.py`).
+ */
+import { type FakeRecord } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+export interface FakePolicyAttachmentLitellm extends FakeRecord {
+    /** Every stored database attachment, exactly as the proxy holds it. */
+    readonly attachments: () => readonly Row[];
+}
+export interface FakePolicyAttachmentOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** Policies that have a production version. A create for any other name is a 404. */
+    readonly policies?: readonly string[];
+    /** Team aliases that exist. A concrete (non-wildcard) `teams` entry outside this set is a 400. */
+    readonly knownTeams?: readonly string[];
+    /** Attachments defined in config.yaml: they appear in the list and can never be deleted. */
+    readonly configAttachments?: readonly Row[];
+    /** `DELETE` answers 403, as for a key that is not allowed. */
+    readonly forbidDelete?: boolean;
+}
+export declare const attachmentRow: (fields: Row) => Row;
+export declare const startFakePolicyAttachmentLitellm: (options?: FakePolicyAttachmentOptions) => FakePolicyAttachmentLitellm;
+//# sourceMappingURL=fake-policy-attachment-litellm.d.ts.map

package/dist/litellm/fake-policy-attachment-litellm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-policy-attachment-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-policy-attachment-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAY,KAAK,UAAU,EAAwB,MAAM,yBAAyB,CAAC;AAC1F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,WAAW,2BAA4B,SAAQ,UAAU;IAC7D,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,kGAAkG;IAClG,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,4FAA4F;IAC5F,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC5C,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,eAAO,MAAM,aAAa,WAAY,GAAG,KAAG,GAQ1C,CAAC;AAEH,eAAO,MAAM,gCAAgC,aAClC,2BAA2B,KACnC,2BAmDF,CAAC"}

package/dist/litellm/fake-policy-litellm.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A fake of LiteLLM's `/policies` routes for tests — TEST ONLY. Skeleton and the rules every fake
+ * follows: fake-registry-base.ts. (The attachment routes are `fake-policy-attachment-litellm.ts`.)
+ *
+ * ★ MEASURED FROM THE LIVE 1.103.0 CONTAINER'S SOURCE (2026-09-30, `policy_endpoints.py` and
+ *   `policy_registry.py`, read, not called): a create makes version 1 AS PRODUCTION, and a second create
+ *   of the name is a 400; the version list is a `find_many` by name (an unknown name is an empty list,
+ *   200); a new version is a DRAFT cloned from production (404 when there is no production) with the
+ *   next version number; `PUT /policies/{id}` edits a DRAFT only (400 otherwise, 404 missing) and writes
+ *   only fields that are not null; `draft → published` and `published → production` (which demotes the
+ *   old production to `published`) are the only promotions, and `draft → production` is a 400;
+ *   `DELETE …/all-versions` answers 200 whether or not anything existed; the list merges in
+ *   config.yaml policies (`definition_location: "config"`).
+ * ⚠️ NOT MODELLED: `pipeline`, the in-memory registry, `is_latest` bookkeeping beyond what a test reads.
+ */
+import { type FakeRecord } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+export interface FakePolicyLitellm extends FakeRecord {
+    /** Every stored version, exactly as the proxy holds it. */
+    readonly versions: () => readonly Row[];
+}
+export interface FakePolicyOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** Policies defined in config.yaml: they appear in `/policies/list` with `definition_location: config`. */
+    readonly configPolicies?: readonly string[];
+    /** A `PUT /policies/{id}` drops an empty list instead of writing it. */
+    readonly editIgnoresEmpty?: boolean;
+}
+export declare const policyRow: (fields: Row) => Row;
+export declare const startFakePolicyLitellm: (options?: FakePolicyOptions) => FakePolicyLitellm;
+//# sourceMappingURL=fake-policy-litellm.d.ts.map

package/dist/litellm/fake-policy-litellm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-policy-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-policy-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAY,KAAK,UAAU,EAAwB,MAAM,yBAAyB,CAAC;AAC1F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,2GAA2G;IAC3G,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,wEAAwE;IACxE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,eAAO,MAAM,SAAS,WAAY,GAAG,KAAG,GAWtC,CAAC;AAEH,eAAO,MAAM,sBAAsB,aAAa,iBAAiB,KAAQ,iBA4IxE,CAAC"}