@homeflare/alchemy 0.42.0 → 0.44.0

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"}

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

@@ -0,0 +1,42 @@
+/**
+ * The shared skeleton of the registry fakes (`fake-team-litellm.ts`, `fake-access-group-litellm.ts`,
+ * `fake-toolset-litellm.ts`, `fake-policy-litellm.ts`, `fake-tool-litellm.ts`) — TEST ONLY, never
+ * imported by `index.ts`.
+ *
+ * ★ Like `fake-litellm.ts` this 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 by each fake.
+ * ★ ONE FAKE PER ROUTE FAMILY, each small, and this file is the part they would otherwise repeat:
+ *   the bearer check, the request log, and the body log a test reads to see what was SENT.
+ * ⚠️ EVERY FAKE'S ANSWERS ARE ITS OWN CHOICE UNLESS ITS HEADER SAYS "MEASURED": shapes come from the
+ *   generated 1.103.0 schema and from reading the 1.103.0 source, never from a live proxy. A test that
+ *   leans on a choice says so.
+ * ⚠️ NEVER ANSWER 5xx. The SDK retries 5xx with backoff, which would cost a test tens of seconds for
+ *   nothing; a failing write is a 400/403/409 here.
+ * ★ `FAKE-*` VALUES ONLY.
+ */
+import type { Row } from './registry-support.ts';
+/** One request that reached a fake. */
+export interface FakeRequest {
+    readonly method: string;
+    readonly path: string;
+}
+/** What every registry fake exposes besides its own rows. */
+export interface FakeRecord {
+    readonly fetch: typeof globalThis.fetch;
+    readonly requests: () => readonly FakeRequest[];
+    /** The JSON bodies of every request that carried one, in order (`POST`/`PUT`/`PATCH`/`DELETE`). */
+    readonly bodies: () => readonly Row[];
+}
+export declare const FAKE_KEY = "sk-test-master";
+export declare const json: (status: number, body: unknown) => Response;
+/** A success with no body, as `DELETE` answers 202/204 on several routes. */
+export declare const empty: (status: number) => Response;
+export interface Call {
+    readonly request: Request;
+    readonly url: URL;
+    /** The parsed JSON body, or `{}` when the request had none. */
+    readonly body: Row;
+}
+export declare const recordingFetch: (masterKey: string, route: (call: Call) => Response | Promise<Response>) => FakeRecord;
+//# sourceMappingURL=fake-registry-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fake-registry-base.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-registry-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,uCAAuC;AACvC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IAChD,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CACvC;AAED,eAAO,MAAM,QAAQ,mBAAmB,CAAC;AAEzC,eAAO,MAAM,IAAI,WAAY,MAAM,QAAQ,OAAO,KAAG,QAC4C,CAAC;AAElG,6EAA6E;AAC7E,eAAO,MAAM,KAAK,WAAY,MAAM,KAAG,QAA0C,CAAC;AAElF,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;CACpB;AAED,eAAO,MAAM,cAAc,cACd,MAAM,SACV,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,KAClD,UAiBF,CAAC"}

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

@@ -10,6 +10,11 @@ export type DeployOptions = {
 export interface FakeStack {
     /** Plan, then apply, `body`. Resolves to the plan; rejects with the apply's failure. */
     readonly deploy: (body: StackBody, options?: DeployOptions) => Promise<Planned>;
+    /**
+     * Everything the state store holds, as JSON, `Redacted` values REVEALED the way Alchemy persists
+     * them (`encodeState`). A test asserts a secret is nowhere in it.
+     */
+    readonly snapshot: () => string;
 }
 /**
  * ⚠️ CREDENTIALS COME FROM `litellmProviders`, NOT AN OUTER `Effect.provide`. The handlers read
@@ -26,7 +31,9 @@ export interface FakeStack {
 export declare const fakeStack: (creds: {
     readonly apiKey: string;
     readonly baseUrl: string;
-}, fetchFn: typeof globalThis.fetch, name?: string) => FakeStack;
+}, fetchFn: typeof globalThis.fetch, name?: string, settings?: {
+    readonly noRetry?: boolean;
+}) => FakeStack;
 /** Every call that changed something, as `METHOD path`, in order. */
 export declare const writesOf: (requests: readonly {
     readonly method: string;

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

@@ -1 +1 @@
-{"version":3,"file":"fake-stack.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-stack.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,8EAA8E;AAC9E,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvD,oFAAoF;AACpF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEjE,6FAA6F;AAC7F,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjF;AAiBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,UACb;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,WACnD,OAAO,UAAU,CAAC,KAAK,oBAE/B,SAoCF,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,QAAQ,aACT,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,KACtE,MAAM,EACsF,CAAC"}
+{"version":3,"file":"fake-stack.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-stack.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,8EAA8E;AAC9E,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvD,oFAAoF;AACpF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEjE,6FAA6F;AAC7F,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAChF;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,CAAC;CACjC;AAiBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,UACb;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,WACnD,OAAO,UAAU,CAAC,KAAK,4BAEtB;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,KACvC,SA4CF,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,QAAQ,aACT,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,KACtE,MAAM,EACsF,CAAC"}

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

@@ -0,0 +1,47 @@
+/**
+ * A fake of LiteLLM's `/team/*` 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, `team_endpoints.py`,
+ *   `object_permission_utils.py`, read, not called): `/team/new` refuses a taken id (400) and ADDS THE
+ *   CALLER AS AN `admin` MEMBER (`_should_auto_add_team_creator`), which `autoAddsCreator` models;
+ *   `/team/update` is partial (`exclude_unset`) and merges `object_permission` BY TOP-LEVEL FIELD (a
+ *   field left out keeps its value, `[]` replaces it); `/team/info` answers a missing team 404 in the
+ *   `ProxyException` envelope; `member_add` and `member_update` refuse an `admin` role on a proxy
+ *   without a licence (400, `community`, the default); `/team/delete` 404s a missing team and DELETES THE
+ *   TEAM'S KEYS (`deletedKeys` records that); `/team/member_delete` is not modelled because nothing here
+ *   may call it, and any request to it is recorded so a test can assert none was made.
+ * ★ ALSO MEASURED: `/team/info` and `/team/delete` answer 404 for ANY exception on the lookup, database
+ *   errors included, which `infoLies` and `deleteLies` model (the team exists and the answer is 404).
+ * ⚠️ NOT MODELLED: budgets, metadata, the Enterprise fields, `access_group` mirroring into groups.
+ */
+import { type FakeRecord } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+export interface FakeTeamLitellm extends FakeRecord {
+    /** Every stored team, exactly as the proxy holds it (`object_permission` included). */
+    readonly teams: () => readonly Row[];
+    /** Team ids whose keys a `/team/delete` removed, in order. */
+    readonly deletedKeys: () => readonly string[];
+}
+export interface FakeTeamOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** No licence: an `admin` role is a 400. Default `true`. */
+    readonly community?: boolean;
+    /** `/team/new` adds the caller as an admin member. Default `true` (measured). */
+    readonly autoAddsCreator?: boolean;
+    /** `/team/info` answers 404 whether or not the team exists (a swallowed database error). */
+    readonly infoLies?: boolean;
+    /** `/team/delete` answers 404 whether or not the team exists. */
+    readonly deleteLies?: boolean;
+    /** `mcp_tool_permissions` comes back as a JSON string, as the source says it can. */
+    readonly toolPermissionsAsString?: boolean;
+    /**
+     * `/team/info` also carries what a real one does and a resource must never copy: the team's KEYS
+     * (`FAKE-hashed-key`), its memberships, and metadata that can hold callback variables.
+     */
+    readonly leaky?: boolean;
+}
+export declare const teamRow: (fields: Row) => Row;
+export declare const startFakeTeamLitellm: (options?: FakeTeamOptions) => FakeTeamLitellm;
+//# sourceMappingURL=fake-team-litellm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fake-team-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-team-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAY,KAAK,UAAU,EAAwB,MAAM,yBAAyB,CAAC;AAC1F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,uFAAuF;IACvF,QAAQ,CAAC,KAAK,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACrC,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,iFAAiF;IACjF,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,4FAA4F;IAC5F,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,qFAAqF;IACrF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,OAAO,WAAY,GAAG,KAAG,GAOpC,CAAC;AAoBH,eAAO,MAAM,oBAAoB,aAAa,eAAe,KAAQ,eA0JpE,CAAC"}

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

@@ -0,0 +1,28 @@
+/**
+ * A fake of LiteLLM's `/v1/tool/{tool_name}` and `/v1/tool/policy` 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, `tool_management_endpoints.py` and
+ *   `db/tool_registry_writer.py`, read, not called): the write is an UPSERT on `tool_name` (a new row
+ *   takes a sent field, else `untrusted`; an existing row takes only the fields sent); neither field
+ *   sent is a 400; a team or key id turns the write into an override of `blocked_tools`, which this
+ *   fake does not model and answers 400 to (nothing here sends one); the read of an unknown tool is a
+ *   404; there is NO delete route for a row. `getSwallowsErrors` models `db_get_tool` catching every
+ *   exception and answering `None`, which the route turns into a 404 for a tool that exists.
+ */
+import { type FakeRecord } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+export interface FakeToolLitellm extends FakeRecord {
+    readonly tools: () => readonly Row[];
+}
+export interface FakeToolOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** The by-name `GET` answers 404 whatever exists (a swallowed database error). */
+    readonly getSwallowsErrors?: boolean;
+    /** `POST /v1/tool/policy` ignores an `output_policy` (a proxy that drops one field). */
+    readonly dropsOutputPolicy?: boolean;
+}
+export declare const toolRow: (fields: Row) => Row;
+export declare const startFakeToolLitellm: (options?: FakeToolOptions) => FakeToolLitellm;
+//# sourceMappingURL=fake-tool-litellm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fake-tool-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-tool-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,eAAgB,SAAQ,UAAU;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,kFAAkF;IAClF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,wFAAwF;IACxF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED,eAAO,MAAM,OAAO,WAAY,GAAG,KAAG,GAKpC,CAAC;AAEH,eAAO,MAAM,oBAAoB,aAAa,eAAe,KAAQ,eAoDpE,CAAC"}

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

@@ -0,0 +1,29 @@
+/**
+ * A fake of LiteLLM's `/v1/mcp/toolset` 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, `mcp_management_endpoints.py` and
+ *   `toolset_db.py`, read, not called): the id is a server-issued uuid (the create has no id field);
+ *   the name is unique (create or rename onto a taken one is a 409); a create answers 201 with the
+ *   row; the edit is partial — absent keeps, `null` clears, EXCEPT a `null` name or `tools`, which are
+ *   no-ops; a delete answers 202 with NO BODY, a missing id is a 404; the by-id read is the table.
+ * ★ ALSO MEASURED: the LIST swallows a database error into `[]` (`list_mcp_toolsets`), which
+ *   `listSwallowsErrors` models — the list then says nothing about what exists.
+ * ⚠️ NOT MODELLED: the caller-scoped narrowing of the list for a non-admin key.
+ */
+import { type FakeRecord } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+export interface FakeToolsetLitellm extends FakeRecord {
+    readonly toolsets: () => readonly Row[];
+}
+export interface FakeToolsetOptions {
+    readonly masterKey?: string;
+    readonly seed?: readonly Row[];
+    /** `GET /v1/mcp/toolset` answers `[]` whatever exists (a swallowed database error). */
+    readonly listSwallowsErrors?: boolean;
+    /** `POST`/`PUT`/`DELETE` answer 403, as for a key that is not PROXY_ADMIN. */
+    readonly forbidWrites?: boolean;
+}
+export declare const toolsetRow: (fields: Row) => Row;
+export declare const startFakeToolsetLitellm: (options?: FakeToolsetOptions) => FakeToolsetLitellm;
+//# sourceMappingURL=fake-toolset-litellm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fake-toolset-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-toolset-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAY,KAAK,UAAU,EAA+B,MAAM,yBAAyB,CAAC;AACjG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IAC/B,uFAAuF;IACvF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,eAAO,MAAM,UAAU,WAAY,GAAG,KAAG,GAMvC,CAAC;AAEH,eAAO,MAAM,uBAAuB,aAAa,kBAAkB,KAAQ,kBAwE1E,CAAC"}

package/dist/litellm/index.d.ts

@@ -11,5 +11,25 @@
  */
 export type { PassThroughEndpointResponse, PassThroughGenericEndpoint, PassThroughGuardrailSettings, } from '@distilled.cloud/litellm/misc';
 export { LiteLLMPassThroughEndpoint, LiteLLMPassThroughEndpointProvider, LitellmConfigPathConflictError, LitellmLiteralSecretHeaderError, LitellmUnaddressableRowError, isLiteLLMPassThroughEndpoint, type PassThroughEndpointAttributes, type PassThroughEndpointError, type PassThroughEndpointProps, } from './pass-through-endpoint.ts';
+export { LiteLLMBudget, LiteLLMBudgetProvider, isLiteLLMBudget, type BudgetAttributes, type BudgetError, type BudgetProps, } from './budget.ts';
+export { LitellmBudgetFieldNotClearedError, LitellmBudgetHardCapUnjustifiedError, LitellmBudgetUnreadableError, } from './budget-errors.ts';
+export { LiteLLMCredential, LiteLLMCredentialProvider, isLiteLLMCredential, type CredentialAttributes, type CredentialError, type CredentialProps, } from './credential.ts';
+export { LitellmCredentialAbsentAfterWriteError, LitellmCredentialEnvUnsetError, LitellmCredentialInvalidError, LitellmCredentialNotConvergedError, LitellmCredentialUnreadableError, } from './credential-errors.ts';
+export { LiteLLMMCPServer, LiteLLMMCPServerProvider, isLiteLLMMCPServer, type McpServerAttributes, type McpServerError, type McpServerProps, } from './mcp-server.ts';
+export { LitellmMcpServerAbsentAfterWriteError, LitellmMcpServerAmbiguousNameError, LitellmMcpServerCredentialEnvUnsetError, LitellmMcpServerDescriptionShadowedError, LitellmMcpServerInvalidError, LitellmMcpServerNotConvergedError, LitellmMcpServerUnreadableError, } from './mcp-server-errors.ts';
+export type { McpAuthType, McpStaticAuthType, McpTransport } from './mcp-server-types.ts';
+export { LiteLLMAccessGroup, LiteLLMAccessGroupProvider, isLiteLLMAccessGroup, type AccessGroupAttributes, type AccessGroupError, type AccessGroupProps, } from './access-group.ts';
+export { LiteLLMPolicyAttachment, LiteLLMPolicyAttachmentProvider, isLiteLLMPolicyAttachment, type PolicyAttachmentAttributes, type PolicyAttachmentError, type PolicyAttachmentProps, } from './policy-attachment.ts';
+export { LiteLLMPolicy, LiteLLMPolicyProvider, isLiteLLMPolicy, type PolicyAttributes, type PolicyError, type PolicyProps, } from './policy.ts';
+export { LiteLLMTeam, LiteLLMTeamProvider, isLiteLLMTeam, type TeamAttributes, type TeamError, type TeamMember, type TeamMemberAttributes, type TeamObjectPermission, type TeamObjectPermissionAttributes, type TeamProps, } from './team.ts';
+export { LiteLLMToolPolicy, LiteLLMToolPolicyProvider, isLiteLLMToolPolicy, type ToolInputPolicy, type ToolOutputPolicy, type ToolPolicyAttributes, type ToolPolicyError, type ToolPolicyProps, } from './tool-policy.ts';
+export { LiteLLMToolset, LiteLLMToolsetProvider, isLiteLLMToolset, type ToolsetAttributes, type ToolsetError, type ToolsetProps, } from './toolset.ts';
+export type { ToolsetTool } from './toolset-types.ts';
+export { LiteLLMModel, LiteLLMModelProvider, isLiteLLMModel, type ModelAttributes, type ModelError, type ModelProps, } from './model.ts';
+export { LitellmModelAbsentAfterWriteError, LitellmModelAmbiguousNameError, LitellmModelConfigFileRowError, LitellmModelForeignRowError, LitellmModelInvalidError, LitellmModelNotConvergedError, LitellmModelPriorGenerationError, LitellmModelUnreadableError, } from './model-errors.ts';
+export { LitellmRegistryAbsentAfterWriteError, LitellmRegistryAmbiguousError, LitellmRegistryInvalidError, LitellmRegistryNotConvergedError, LitellmRegistryUnreadableError, type RegistryError, } from './registry-errors.ts';
+export { LiteLLMKey, LiteLLMKeyProvider, isLiteLLMKey, type KeyAttributes, type KeyError, type KeyProps, } from './key.ts';
+export { LitellmKeyAbsentAfterWriteError, LitellmKeyAliasChangedError, LitellmKeyAliasEmptyError, LitellmKeyDebugLoggingError, LitellmKeyAmbiguousAliasError, LitellmKeyFieldNotAppliedError, LitellmKeyTransportError, LitellmKeyUnreadableError, LitellmKeyValueMalformedError, LitellmKeyValueMissingError, LitellmKeyValueNotHonouredError, LitellmKeyValueRequiredError, } from './key-errors.ts';
+export { LitellmKeyCallbackMetadataDeclaredError, LitellmKeyCallbackMetadataLiveError, } from './key-metadata-errors.ts';
 export { litellmProviders } from './providers.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/litellm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,YAAY,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,4BAA4B,EAC5B,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,GAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/litellm/index.ts"],"names":[],"mappings":"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"}