@homeflare/alchemy 0.43.0 → 0.45.0

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

@@ -0,0 +1,24 @@
+/**
+ * Whether a stateless `LiteLLM.Model` reconcile may write the live row it found.
+ *
+ * ⛔ A ROW WITH NO SEAL IS NOT YET THIS GENERATION'S. `output` is undefined on a create and on a
+ *   `replacing` row Apply committed before reconcile (Apply.ts), and a probe result carries
+ *   `paramsSeal: ''`. Either way the live row may belong to someone else.
+ * ★ TWO ROWS THAT LOOK THE SAME AND ARE NOT. A deterministic id this declaration would create is
+ *   ours by construction. An older generation's `attr.id` (ownership/rows.ts) is our own serving
+ *   deployment from before this replacement — recording it here makes destroy() delete it. A
+ *   declared id needs `--adopt` on a create or an unfinished generation; an unpinned row with any
+ *   other id is adopted only on a create (ownership/adopt.ts).
+ */
+import * as Effect from 'effect/Effect';
+import { LitellmModelForeignRowError, LitellmModelPriorGenerationError } from './model-errors.ts';
+import type { ModelAttributes, ModelProps } from './model-types.ts';
+export declare const claimStatelessRow: (args: {
+    readonly fqn: string;
+    readonly instanceId: string;
+    readonly output: ModelAttributes | undefined;
+    readonly news: ModelProps;
+    readonly beforeId: string;
+    readonly wanted: string;
+}) => Effect.Effect<void, LitellmModelPriorGenerationError | LitellmModelForeignRowError>;
+//# sourceMappingURL=model-claim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-claim.d.ts","sourceRoot":"","sources":["../../src/litellm/model-claim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,EAAE,2BAA2B,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAClG,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEpE,eAAO,MAAM,iBAAiB,SAAU;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gCAAgC,GAAG,2BAA2B,CAyClF,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { ModelProps } from './model-types.ts';
+/**
+ * The declared `litellm_params` as the reference form names them — the input to the seal. `model`
+ * and `api_base` are what the proxy routes on; `api_key` is the reference LiteLLM resolves in its
+ * own environment. No value, ever: there is no lookup and no environment here.
+ */
+export declare const declaredValues: (props: ModelProps) => Record<string, string>;
+/** `scrypt:<salt>:<digest>` of declared values, for `paramsSeal`. ⛔ Never a secret value. */
+export declare const sealFromValues: (values: Record<string, string>) => string;
+/** Whether the declaration's values are the ones `sealed` was made from. */
+export declare const sealState: (props: ModelProps, sealed: string) => 'match' | 'stale';
+//# sourceMappingURL=model-credential.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-credential.d.ts","sourceRoot":"","sources":["../../src/litellm/model-credential.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,cAAc,UAAW,UAAU,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAKvE,CAAC;AAEF,6FAA6F;AAC7F,eAAO,MAAM,cAAc,WAAY,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MAAsB,CAAC;AAEvF,4EAA4E;AAC5E,eAAO,MAAM,SAAS,UAAW,UAAU,UAAU,MAAM,KAAG,OAAO,GAAG,OACR,CAAC"}

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

@@ -0,0 +1,119 @@
+/**
+ * The typed refusals `LiteLLM.Model` raises on top of `@distilled.cloud/litellm`'s own SDK errors.
+ *
+ * ⛔ NO MESSAGE HERE MAY CARRY A CREDENTIAL: only names, ids, field names and the NAME of an
+ *   environment variable, exactly like mcp-server-errors.ts.
+ */
+import type { BadRequest, NotFound } from '@distilled.cloud/litellm/Errors';
+import type * as models from '@distilled.cloud/litellm/model_management';
+declare const LitellmModelInvalidError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelInvalidError";
+} & Readonly<A>;
+/** A declaration the resource refuses before any request: a combination nobody meant. */
+export declare class LitellmModelInvalidError extends LitellmModelInvalidError_base<{
+    readonly modelName: string;
+    readonly problem: string;
+}> {
+    get message(): string;
+}
+declare const LitellmModelAmbiguousNameError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelAmbiguousNameError";
+} & Readonly<A>;
+/**
+ * More than one live deployment carries the declared `model_name`, so adopt-by-name cannot say
+ * which one is meant — LiteLLM runs several deployments under one group name on purpose. Declare
+ * `id` to pick one; nothing is adopted, updated or deleted on a guess.
+ */
+export declare class LitellmModelAmbiguousNameError extends LitellmModelAmbiguousNameError_base<{
+    readonly modelName: string;
+    readonly ids: readonly string[];
+}> {
+    get message(): string;
+}
+declare const LitellmModelUnreadableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelUnreadableError";
+} & Readonly<A>;
+/** `GET /model/info` answered something that is not a list of deployments. */
+export declare class LitellmModelUnreadableError extends LitellmModelUnreadableError_base<{
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+declare const LitellmModelAbsentAfterWriteError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelAbsentAfterWriteError";
+} & Readonly<A>;
+/**
+ * A create or update returned no error, yet no read answers a deployment with the id it was written
+ * under: not in the list, and not by the id it would carry.
+ */
+export declare class LitellmModelAbsentAfterWriteError extends LitellmModelAbsentAfterWriteError_base<{
+    readonly modelName: string;
+    readonly id: string;
+}> {
+    get message(): string;
+}
+declare const LitellmModelNotConvergedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelNotConvergedError";
+} & Readonly<A>;
+/**
+ * The write returned no error but the deployment still differs from the declaration. The PATCH
+ * merge writes the keys it was sent (`update_db_model` at v1.103.0); a field the read-back still
+ * shows different is refused here instead of being reported as converged.
+ */
+export declare class LitellmModelNotConvergedError extends LitellmModelNotConvergedError_base<{
+    readonly modelName: string;
+    readonly id: string;
+    readonly fields: readonly string[];
+}> {
+    get message(): string;
+}
+declare const LitellmModelForeignRowError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelForeignRowError";
+} & Readonly<A>;
+/**
+ * A reconcile with no state found a live row under the declared name whose id is not the one this
+ * declaration would create, and nothing vouchsafes it: writing over it would take over another
+ * owner's deployment. `replace` says whether this generation is a replace's new identity (a changed
+ * declared id), which `--adopt` does not cover — the object must be removed first.
+ */
+export declare class LitellmModelForeignRowError extends LitellmModelForeignRowError_base<{
+    readonly modelName: string;
+    readonly id: string;
+    readonly replace: boolean;
+}> {
+    get message(): string;
+}
+declare const LitellmModelPriorGenerationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelPriorGenerationError";
+} & Readonly<A>;
+/**
+ * The row a reconcile found is served from the proxy's config file (`model_info.db_model: false`),
+ * not from the database, so the DB API cannot manage it. Remove it from the config file first.
+ */
+/**
+ * The live row a stateless reconcile found is an OLDER generation of this FQN's own state chain
+ * (`attr.id` walked through `old`). It is still the serving deployment: the replacement that
+ * followed it never committed. Taking the row over would store that id on the new generation, and
+ * `destroy()` then deletes the old generation by the same id.
+ * ⛔ THE RECOVERY IS STATE, NOT THE ROW. `alchemy state rm` deletes the state record and leaves the
+ *   deployment; deleting the live row takes the serving model out of its group.
+ */
+export declare class LitellmModelPriorGenerationError extends LitellmModelPriorGenerationError_base<{
+    readonly modelName: string;
+    readonly id: string;
+    readonly fqn: string;
+}> {
+    get message(): string;
+}
+declare const LitellmModelConfigFileRowError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LitellmModelConfigFileRowError";
+} & Readonly<A>;
+export declare class LitellmModelConfigFileRowError extends LitellmModelConfigFileRowError_base<{
+    readonly modelName: string;
+    readonly id: string;
+}> {
+    get message(): string;
+}
+export type ModelError = models.AddNewModelModelNewPostError | models.DeleteModelModelDeletePostError | models.GetModelInfoV1ModelInfoError | models.PatchModelModelModelIdUpdatePatchError | BadRequest | NotFound | LitellmModelInvalidError | LitellmModelAmbiguousNameError | LitellmModelUnreadableError | LitellmModelAbsentAfterWriteError | LitellmModelNotConvergedError | LitellmModelForeignRowError | LitellmModelPriorGenerationError | LitellmModelConfigFileRowError;
+export {};
+//# sourceMappingURL=model-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-errors.d.ts","sourceRoot":"","sources":["../../src/litellm/model-errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,KAAK,KAAK,MAAM,MAAM,2CAA2C,CAAC;;;;AAGzE,yFAAyF;AACzF,qBAAa,wBAAyB,SAAQ,8BAA6C;IACzF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,8BAA+B,SAAQ,oCAElD;IACA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED,8EAA8E;AAC9E,qBAAa,2BAA4B,SAAQ,iCAAgD;IAC/F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,uCAErD;IACA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,6BAA8B,SAAQ,mCAEjD;IACA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;;GAKG;AACH,qBAAa,2BAA4B,SAAQ,iCAAgD;IAC/F,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAQ7B;CACF;;;;AAED;;;GAGG;AACH;;;;;;;GAOG;AACH,qBAAa,gCAAiC,SAAQ,sCAEpD;IACA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAQ7B;CACF;;;;AAED,qBAAa,8BAA+B,SAAQ,oCAElD;IACA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;AAED,MAAM,MAAM,UAAU,GAClB,MAAM,CAAC,4BAA4B,GACnC,MAAM,CAAC,+BAA+B,GACtC,MAAM,CAAC,4BAA4B,GACnC,MAAM,CAAC,sCAAsC,GAC7C,UAAU,GACV,QAAQ,GACR,wBAAwB,GACxB,8BAA8B,GAC9B,2BAA2B,GAC3B,iCAAiC,GACjC,6BAA6B,GAC7B,2BAA2B,GAC3B,gCAAgC,GAChC,8BAA8B,CAAC"}

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

@@ -0,0 +1,78 @@
+/**
+ * Refusals, wire bodies, the read shape and the comparison for `LiteLLM.Model`, testable without
+ * a server. Credential handling is model-credential.ts's; the URL rules are mcp-server-url.ts's.
+ *
+ * ⛔ WHAT IS COMPARED, WITH ENCRYPTION IN MIND. LiteLLM stores `litellm_params` encrypted when the
+ *   proxy runs with a database master key (`prisma_client.py`, `encrypt_value`, tag v1.103.0) and
+ *   answers a row whose `litellm_params` are decrypted, with `api_key` stripped (measured at
+ *   v1.103.0) — `/v2/model/info`'s docstring still says api keys and api_base are left out. So:
+ *   - `model_name`, `model_info.id`, `mode`, `base_model` and `access_groups` are compared from
+ *     the fields the read returns.
+ *   - `model`, `api_base` and `api_key` are compared through a DIGEST of the DECLARED values
+ *     (`declaredDigest`), carried in attributes as `paramsSeal`, never a digest of the live row.
+ *     A plan therefore reports drift when the declaration changes and stays quiet when the proxy
+ *     hides a field it was told before — the false-drift answer the encrypted row leaves no other
+ *     way to. A field the proxy DOES return (`model`) is additionally compared when the read
+ *     carries it; the seal is what decides when the read says nothing.
+ * ⛔ A LIVE `api_key` IS NEVER OVERWRITTEN BY AN ADOPTED ROW'S NOTHING. `apiKey` omitted on an
+ *   adopted row sends no `api_key` and the live reference is kept; `differing` reports no drift
+ *   for it. Declaring `apiKey` is what moves the row onto `os.environ/NAME`.
+ * ⛔ EVERYTHING AN EXISTING ROW NEEDS GOES TO ONE PATCH `/model/{model_id}/update`. At the tag
+ *   the SDK was generated from (OpenAPI 1.103.0), POST `/model/update`'s `update_model` REBUILDS
+ *   `litellm_params` from the parsed request model and REPLACES the column: a key the model does
+ *   not declare (`extra_headers`, `weight`, `order`) is DELETED from the stored row, and a
+ *   non-`None` pydantic default (`false` on the five flags in `LEAVE_ALONE_PARAMS`) overwrites
+ *   it — measured on a throwaway 1.103.0 proxy, and the reason a params POST is never sent. The
+ *   PATCH route's `update_db_model` instead MERGES: sent keys land, the rest of the row is
+ *   preserved, and a JSON `null` keeps the stored value. So one PATCH carries the managed
+ *   `litellm_params` (with `null` for those five flags), the `model_name` when it changed, and
+ *   the `model_info` fields — `access_groups`, `mode`, `base_model`, and the row's own `id`, so
+ *   an adopt-by-id re-affirms the row it pinned. `model_name` is sent only when it changed,
+ *   because a same-name write would collide with another deployment in the group (model.ts).
+ */
+import type * as models from '@distilled.cloud/litellm/model_management';
+import { type ModelAttributes, type ModelProps } from './model-types.ts';
+/** The first reason a declaration is refused, or `undefined`. Pure: no environment, no server. */
+export declare const firstProblem: (props: ModelProps) => string | undefined;
+/** The digest of the DECLARED values, for `paramsSeal`. Pure: no environment, no lookup. */
+export declare const declaredDigest: (props: ModelProps) => string;
+/**
+ * Wire names of the fields where the live row and the declaration disagree.
+ *
+ * `model` is compared only when the read carries it (an encrypted row omits it); the seal decides
+ * otherwise, and model.ts's diff turns a changed seal into an update. `model_name` mismatch on a
+ * pinned id is identity drift — replace in model.ts, update here only when the name changed and
+ * the id stayed.
+ */
+export declare const differing: (live: ModelAttributes, props: ModelProps) => readonly string[];
+/**
+ * One row of `/model/info`, as attributes. ⛔ Copies no `litellm_params` field but `model`, and
+ * only when the read returns an OBJECT: the fields a row hides (`api_key` is stripped at
+ * v1.103.0) are never mistaken for declared values — `api_base` and any `api_key` are never
+ * copied at all. `dbModel` records `model_info.db_model` (false = served from the proxy's config
+ * file), defaulting to true when the read omits it. The digest is the caller's (model.ts fills
+ * `paramsSeal` from state, a row cannot supply one).
+ */
+export declare const toAttributes: (row: Record<string, unknown>) => ModelAttributes;
+/** A create names the group and pins the id it asked for on `model_info` of the POST body. */
+export declare const createBody: (props: ModelProps, modelId: string) => models.AddNewModelModelNewPostRequest;
+/**
+ * PATCH `/model/{model_id}/update`: everything an existing row needs, in the ONE write a
+ * converge fires (model.ts). `update_db_model` MERGES (v1.103.0, measured), so:
+ *   - `litellm_params` carries the managed keys (with `null` for the five non-`None` defaults
+ *     this resource does not own); the merge keeps every stored key the declaration does not
+ *     own (`extra_headers`, `weight`, `order`), which is exactly what POST `/model/update`
+ *     would DELETE by rebuilding the column.
+ *   - `model_info` carries `access_groups` (always present: an omitted list is "no groups" and
+ *     must be able to clear), `mode` and `base_model` only when declared, and the row's own
+ *     `id`, so an adopt-by-id re-affirms the row it pinned.
+ *   - `model_name` only when it changed: a same-name write would collide with a sibling
+ *     deployment in the group (model.ts). Not a seal stamp: a matching row records `paramsSeal`
+ *     locally (model.ts).
+ *
+ * ⚠️ `Record`, then a widening cast, for the same reason as {@link modelInfoOf}: the generated
+ *   1.103.0 `LitellmTypesRouterModelInfo` declares neither `access_groups` nor `mode`, while the
+ *   vendor model allows both (`extra="allow"`) and the read answers both.
+ */
+export declare const patchBody: (props: ModelProps, live: ModelAttributes) => Record<string, unknown>;
+//# sourceMappingURL=model-form.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-form.d.ts","sourceRoot":"","sources":["../../src/litellm/model-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,2CAA2C,CAAC;AACzE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,UAAU,EAGhB,MAAM,kBAAkB,CAAC;AAI1B,kGAAkG;AAClG,eAAO,MAAM,YAAY,UAAW,UAAU,KAAG,MAAM,GAAG,SA+BzD,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,cAAc,UAAW,UAAU,KAAG,MAA+C,CAAC;AAKnG;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,SAAU,eAAe,SAAS,UAAU,KAAG,SAAS,MAAM,EAUnF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,eAoB3D,CAAC;AAqDF,8FAA8F;AAC9F,eAAO,MAAM,UAAU,UACd,UAAU,WACR,MAAM,KACd,MAAM,CAAC,8BAOT,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,UAAW,UAAU,QAAQ,eAAe,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAQ1F,CAAC"}

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

@@ -0,0 +1,13 @@
+import * as Effect from 'effect/Effect';
+import { LitellmModelAmbiguousNameError } from './model-errors.ts';
+import type { ModelAttributes, ModelProps } from './model-types.ts';
+/**
+ * The live row among the LISTED ones, or `undefined`. A pinned id (from state, else declared) wins;
+ * otherwise the name decides, and an ambiguous name is refused.
+ */
+export declare const locate: (rows: readonly ModelAttributes[], props: ModelProps, output: ModelAttributes | undefined) => Effect.Effect<never, LitellmModelAmbiguousNameError, never> | Effect.Effect<ModelAttributes | undefined, never, never>;
+/** The id a create asks for: the recorded one, else the declared one, else a deterministic name. */
+export declare const wantedId: (id: string, instanceId: string, props: ModelProps, output: ModelAttributes | undefined) => Effect.Effect<string, never, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage>;
+/** The live row this declaration means, from the list, else from the table by the id it would use. */
+export declare const findLive: (id: string, instanceId: string, props: ModelProps, output: ModelAttributes | undefined) => Effect.Effect<ModelAttributes | undefined, import("@distilled.cloud/caddy").BadRequest | LitellmModelAmbiguousNameError | import("./model-errors.ts").LitellmModelUnreadableError | import("@distilled.cloud/litellm/model_management").GetModelInfoV1ModelInfoError, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=model-locate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-locate.d.ts","sourceRoot":"","sources":["../../src/litellm/model-locate.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,MAAM,SACX,SAAS,eAAe,EAAE,SACzB,UAAU,UACT,eAAe,GAAG,SAAS,2HAapC,CAAC;AAEF,oGAAoG;AACpG,eAAO,MAAM,QAAQ,OACf,MAAM,cACE,MAAM,SACX,UAAU,UACT,eAAe,GAAG,SAAS,mHAMyC,CAAC;AAE/E,sGAAsG;AACtG,eAAO,MAAM,QAAQ,OACf,MAAM,cACE,MAAM,SACX,UAAU,UACT,eAAe,GAAG,SAAS,2ZAMjC,CAAC"}

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

@@ -0,0 +1,59 @@
+/**
+ * The five LiteLLM `/model/*` calls `LiteLLM.Model` uses, through the SDK's typed operations in
+ * `@distilled.cloud/litellm/model_management` (LiteLLM 1.103.0; names verified in the generated
+ * source, never guessed):
+ *
+ *   list    `getModelInfoV1ModelInfo`            GET   /model/info
+ *   read    `getModelInfoV1ModelInfo`            GET   /model/info?litellm_model_id={id}
+ *   create  `addNewModelModelNewPost`            POST  /model/new
+ *   patch   `patchModelModelModelIdUpdatePatch`  PATCH /model/{model_id}/update
+ *   delete  `deleteModelModelDeletePost`         POST  /model/delete
+ *
+ * The SDK is generated from LiteLLM OpenAPI **1.103.0** (`model_management.ts`'s header). At that
+ * tag, and at v1.100.0, `model_info_v1` raises HTTP 400 when the router has no such deployment
+ * (`proxy_server.py`, "Model id = … not found on litellm proxy"), not 404. The same 400 is also
+ * "no rights" or a bad filter. The PATCH route's `update_db_model` MERGES: `litellm_params`,
+ * `model_name` and `model_info` (`access_groups`, `mode`, `base_model`) all land without
+ * rebuilding the column, which is the one write `LiteLLM.Model` converges with (model-form.ts).
+ * POST `/model/update` REBUILDS `litellm_params` and deletes stored keys the request model does
+ * not declare, so this resource never sends it.
+ *
+ * ⛔ LIST-FIRST READS. One GET of the whole list answers a group, an id and absence unambiguously,
+ *   the way `budget-operations.ts` reads. The by-id read is the same route with the
+ *   `litellm_model_id` filter, used only where the list cannot decide (a write-back on a row the
+ *   list may not show yet).
+ * ⛔ NO MESSAGE SNIFFING (S21). The by-id read's 400 is undeclared on the generated operation, so
+ *   it decodes at run time as the shared `BadRequest` (`HTTP_STATUS_MAP`). `catchTag` matches the
+ *   tag — the same match `deleteModel` uses — so a later declared class with that tag is still
+ *   seen. A 400 is absence only when a re-list also lacks the id. A 404 is the same absence.
+ *   Any other failure propagates.
+ * ⛔ THE ROW'S PARAMS ARE NEVER READ INTO STATE: `toAttributes` (model-form.ts) copies `model`
+ *   only when `litellm_params` is an object, and never `api_base` or `api_key` — the v1.103.0
+ *   read answers params DECRYPTED but STRIPS `api_key` (measured). What was declared is
+ *   remembered as a digest instead.
+ * ⚠️ Unlike pass-through endpoints, each deployment is its own DB row: no semaphore.
+ */
+import * as models from '@distilled.cloud/litellm/model_management';
+import type { BadRequest } from '@distilled.cloud/litellm/Errors';
+import * as Effect from 'effect/Effect';
+import { type LitellmOpContext } from './operations.ts';
+import type { ModelAttributes } from './model-types.ts';
+import { LitellmModelUnreadableError } from './model-errors.ts';
+/** Every deployment row, config-file ones included. This is the read that locates and diffs. */
+export declare const listModels: () => Effect.Effect<readonly ModelAttributes[], models.GetModelInfoV1ModelInfoError | LitellmModelUnreadableError, LitellmOpContext>;
+export declare const readModelRow: (modelId: string) => Effect.Effect<ModelAttributes | undefined, BadRequest | LitellmModelUnreadableError | models.GetModelInfoV1ModelInfoError, LitellmOpContext>;
+/** POST /model/new. The answer carries no usable row (the fake answers `{}`), so the id asked for is the one tracked. */
+export declare const createModel: (body: models.AddNewModelModelNewPostRequest) => Effect.Effect<void, models.AddNewModelModelNewPostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+/**
+ * PATCH `/model/{model_id}/update`. The ONE write a converge of an existing row fires: its merge
+ * carries `litellm_params`, `model_name` and `model_info` together (model-form.ts).
+ */
+export declare const patchModel: (body: Record<string, unknown>) => Effect.Effect<void, models.PatchModelModelModelIdUpdatePatchError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+/**
+ * Idempotent BY THIS FUNCTION, not by the vendor. A `BadRequest` re-lists and is swallowed only
+ * when the id is genuinely absent — the same delete can also be refused for lack of rights or a
+ * disconnected DB, which leaves the row live and must never be reported as done
+ * (budget-operations.ts's rule; never the message text, S21).
+ */
+export declare const deleteModel: (modelId: string) => Effect.Effect<void, import("@distilled.cloud/caddy").BadGateway | models.BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | LitellmModelUnreadableError | 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 | models.UnprocessableEntity, LitellmOpContext>;
+//# sourceMappingURL=model-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/model-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,KAAK,MAAM,MAAM,2CAA2C,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,iCAAiC,CAAC;AAC5E,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAmChE,gGAAgG;AAChG,eAAO,MAAM,UAAU,QAAO,MAAM,CAAC,MAAM,CACzC,SAAS,eAAe,EAAE,EAC1B,MAAM,CAAC,4BAA4B,GAAG,2BAA2B,EACjE,gBAAgB,CACgE,CAAC;AAenF,eAAO,MAAM,YAAY,YAAa,MAAM,iJAgBzC,CAAC;AAEJ,yHAAyH;AACzH,eAAO,MAAM,WAAW,SAAU,MAAM,CAAC,8BAA8B,yHACC,CAAC;AAEzE;;;GAGG;AACH,eAAO,MAAM,UAAU,SAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mIAKjC,CAAC;AAExB;;;;;GAKG;AACH,eAAO,MAAM,WAAW,YAAa,MAAM,spBAUxC,CAAC"}

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

@@ -0,0 +1,91 @@
+/**
+ * What a `LiteLLM.Model` declares (props) and what is remembered about it (attributes).
+ *
+ * ⛔ NO CREDENTIAL VALUE IS A PROP OR AN ATTRIBUTE (S25). Alchemy persists props AND attributes
+ *   unencrypted (`StateEncoding.ts` writes a `Redacted` value's inner string beside its tag,
+ *   measured on alchemy 2.0.0-beta.79), so `apiKey` is `{ fromEnv: 'NAME' }`: the NAME is stored,
+ *   the value lives only in the deploying process and on the wire, and it is sent in LiteLLM's own
+ *   reference form `os.environ/NAME` — so the PROXY reads it from ITS environment at call time and
+ *   the proxy's own DB row never carries a literal either. A `Redacted` prop would still land in
+ *   state as plaintext (mcp-server-types.ts's reasoning, same store).
+ * ⛔ THE LIVE ROW'S `litellm_params` ARE NEVER MIRRORED INTO ATTRIBUTES. At v1.103.0 the read
+ *   answers the stored params DECRYPTED but STRIPS `api_key` (measured on a live 1.103.0 proxy),
+ *   and anything mirrored would land in state as plaintext — Alchemy persists attributes
+ *   unencrypted. So a read compares only the visible fields the proxy returns, and this
+ *   resource's own attributes carry a DIGEST of the DECLARED values (`paramsSeal`), never the
+ *   values: that is how a plan notices a declared credential moved when the read cannot show it.
+ * ⚠️ NOT MODELLED, on purpose: the rest of `litellm_params` (rpm/tpm, timeouts, fallbacks,
+ *   wildcard routing params, `mock_response`, vertex/aws credential blobs, …), cost fields on
+ *   `model_info` beyond what the read returns, `teams`, and the config-file-only rows
+ *   (`db_model: false`) — a reconcile that finds one REFUSES it (model-errors.ts): the DB
+ *   API cannot manage what the proxy serves from its config file.
+ */
+import type { FromEnv } from '../secrets/write-only.ts';
+/**
+ * The LiteLLM-SDK path of the deployment: a provider prefix, then the upstream model, such as
+ * `xai/grok-4.7` or `cloudflare/@cf/meta/llama-3.1-8b-instruct`. Required: LiteLLM needs it to
+ * pick the provider handler, and an unprefixed name is ambiguous.
+ */
+export type ModelLiteLLMPath = string;
+export interface ModelProps {
+    /**
+     * The group name callers use (`/chat/completions` `model: …`), one group = one or more
+     * deployments. This is also how an existing row is ADOPTED: the live row whose `model_name`
+     * equals it. ⛔ Renaming a group changes nothing upstream — LiteLLM keys deployments by id —
+     * so a changed `modelName` with no pinned `id` is a REPLACE: the new group gets a fresh id, and
+     * the old row survives under the default `RemovalPolicy.retain()` (opt in to `destroy()` to
+     * delete it). A pinned `id` is that row: the same deployment is renamed in place
+     * (`patchBody` sends `model_name`), and keys routing to the old name miss.
+     */
+    readonly modelName: string;
+    /**
+     * Pins the live row (adopts by id) or chooses the id a create asks for. Without it, a live row
+     * is found by `modelName` and a new one gets a deterministic physical name. A group name is
+     * shared by several deployments on a live proxy: one id selects exactly one.
+     */
+    readonly id?: string;
+    /** The LiteLLM-SDK path, provider prefix included (`xai/grok-4.7`, `cloudflare/@cf/...`). */
+    readonly model: string;
+    /**
+     * The upstream base URL, when the deployment needs one. ⛔ Refused if it carries userinfo, a
+     * fragment or a secret-looking query parameter (`?token=…`): the URL is a prop, so it lands in
+     * state. Declare the credential as `apiKey` instead.
+     */
+    readonly apiBase?: string;
+    /**
+     * The upstream credential, by the NAME of the environment variable that holds it — sent to the
+     * proxy as LiteLLM's own reference form `os.environ/NAME`, never a literal value. Omitted
+     * leaves the live credential exactly as the proxy holds it (an adopted row is never blanked).
+     */
+    readonly apiKey?: FromEnv;
+    /** The deployment's capabilities, `mode` in LiteLLM's model_info — `chat`, `embedding`, …. */
+    readonly mode?: string;
+    /** The upstream model this one masquerades as, for cost/prompt mapping. */
+    readonly baseModel?: string;
+    /** Access groups this deployment belongs to. Always compared (as a set), default empty. */
+    readonly accessGroups?: readonly string[];
+}
+export interface ModelAttributes {
+    readonly id: string;
+    readonly modelName: string;
+    /** Whether the row is served from the database (`model_info.db_model`); false = config-file row. */
+    readonly dbModel: boolean;
+    /** The provider-prefixed path as the live row carries it (null when the read omits it). */
+    readonly model: string | null;
+    readonly mode: string | null;
+    readonly baseModel: string | null;
+    readonly accessGroups: readonly string[];
+    /**
+     * Digest of the DECLARED params this write would send (`scrypt:<salt>:<digest>`), or `''`.
+     * ⛔ Never the values, never a digest of the LIVE row. This is how a plan notices that the
+     * environment variable behind `apiKey` rotated: the read strips `api_key`, so the seal is the
+     * only signal a declared credential moved (model-form.ts's `declaredDigest`).
+     */
+    readonly paramsSeal: string;
+}
+/** Whether a value is not a string with something in it. Takes `unknown`: a declaration can say anything. */
+export declare const isBlank: (value: unknown) => boolean;
+export declare const MODES: readonly string[];
+/** Whether `model` carries a provider prefix, LiteLLM's `litellm.utils.get_llm_provider` rule. */
+export declare const hasProviderPrefix: (model: string) => boolean;
+//# sourceMappingURL=model-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-types.d.ts","sourceRoot":"","sources":["../../src/litellm/model-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEtC,MAAM,WAAW,UAAU;IACzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,6FAA6F;IAC7F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,8FAA8F;IAC9F,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oGAAoG;IACpG,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2FAA2F;IAC3F,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,6GAA6G;AAC7G,eAAO,MAAM,OAAO,UAAW,OAAO,KAAG,OACS,CAAC;AAEnD,eAAO,MAAM,KAAK,EAAE,SAAS,MAAM,EAelC,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,iBAAiB,UAAW,MAAM,KAAG,OAAwC,CAAC"}

package/dist/litellm/model.d.ts

@@ -0,0 +1,88 @@
+/**
+ * `LiteLLM.Model` — one deployment row of LiteLLM's model registry (`/model/info`), an upstream
+ * model the proxy's router serves under a group name. A group name can carry SEVERAL deployments
+ * (that is LiteLLM's load balancing); this resource owns exactly one row.
+ *
+ * ★ ADOPT BY NAME. `modelName` finds the live row whose group name matches; declare `id` to pin one
+ *   instead. A live row with no state is `Unowned`, so it needs `--adopt`. A name matching more
+ *   than one listed row is refused, never guessed at (`LitellmModelAmbiguousNameError`).
+ * ★ `defaultRemovalPolicy: 'retain'` — a deployment's removal takes it out of its routing group for
+ *   every key that reaches it. Opt in with `.pipe(RemovalPolicy.destroy())`.
+ * ⛔ THE CREDENTIAL IS `{ fromEnv: 'NAME' }`, NEVER A VALUE (S25): it is sent in LiteLLM's own
+ *   reference form `os.environ/NAME` and the proxy resolves it in its own environment — nothing
+ *   here reads `process.env` (model-credential.ts), so a value could never be sealed truthfully.
+ *   A row's stored params come back DECRYPTED at v1.103.0 but with `api_key` STRIPPED (measured),
+ *   so a plan compares the visible fields plus a digest of the DECLARED values (`paramsSeal`) —
+ *   never the values themselves, which belong in the proxy's DB only (model-form.ts).
+ * ⚠️ A RENAME IS A NEW GROUP when the id is not pinned: the old row survives under 'retain', the
+ *   new group gets a fresh deterministic id. With a pinned id the SAME row is renamed — the caller
+ *   chose the row (model-types.ts).
+ * ⚠️ UNMEASURED AT 1.103.0, guarded by a read back: whether `/model/new` honours a supplied
+ *   `model_info.id`. The answer is an untyped body, so the id ASKED FOR is the one tracked
+ *   (model-operations.ts); a proxy that issued its own id fails loudly
+ *   (`LitellmModelAbsentAfterWriteError`) instead of recording a row it cannot identify.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import { LitellmModelAbsentAfterWriteError, LitellmModelConfigFileRowError, LitellmModelInvalidError, LitellmModelNotConvergedError } from './model-errors.ts';
+import type { ModelAttributes, ModelProps } from './model-types.ts';
+export type { ModelAttributes, ModelProps };
+export type { ModelError } from './model-errors.ts';
+export interface LiteLLMModel extends Resource<'LiteLLM.Model', ModelProps, ModelAttributes> {
+}
+export declare const LiteLLMModel: import("alchemy").ResourceClass<LiteLLMModel>;
+export declare const isLiteLLMModel: (value: unknown) => value is LiteLLMModel;
+type Args<P> = {
+    fqn: string;
+    id: string;
+    instanceId: string;
+    output: ModelAttributes | undefined;
+} & P;
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export declare const modelHandlers: {
+    /**
+     * ⛔ WITH NO `output` THIS IS ALCHEMY'S ADOPTION PROBE, AND THE ONLY PLAN-TIME HOOK A NEW MODEL
+     *   GETS — so the refusals run here too, as a defect (mcp-server.ts: the cold-start probe must
+     *   fail the plan, and a recovery read must degrade to "nothing recovered", which only a defect
+     *   does). The v1.103.0 read answers params decrypted with `api_key` stripped, so this refusal
+     *   is the declaration's (`firstProblem`), before Apply commits props into unencrypted state.
+     */
+    read: ({ id, instanceId, olds, output }: Args<{
+        olds: ModelProps;
+    }>) => Effect.Effect<ModelAttributes | undefined, import("@distilled.cloud/caddy").BadRequest | import("./model-errors.ts").LitellmModelAmbiguousNameError | import("./model-errors.ts").LitellmModelUnreadableError | import("@distilled.cloud/litellm/model_management").GetModelInfoV1ModelInfoError, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    diff: ({ instanceId, news, output, }: {
+        instanceId: string;
+        news: Input<ModelProps>;
+        output: ModelAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'replace';
+        readonly deleteFirst: false;
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'noop';
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'update';
+    } | undefined, LitellmModelInvalidError, never>;
+    reconcile: ({ fqn, id, instanceId, news, output }: Args<{
+        news: ModelProps;
+    }>) => Effect.Effect<{
+        id: string;
+        modelName: string;
+        dbModel: boolean;
+        model: string | null;
+        mode: string | null;
+        baseModel: string | null;
+        accessGroups: readonly string[];
+        paramsSeal: string;
+    }, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | LitellmModelAbsentAfterWriteError | import("./model-errors.ts").LitellmModelAmbiguousNameError | LitellmModelConfigFileRowError | import("./model-errors.ts").LitellmModelForeignRowError | LitellmModelInvalidError | LitellmModelNotConvergedError | import("./model-errors.ts").LitellmModelPriorGenerationError | import("./model-errors.ts").LitellmModelUnreadableError | 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/model_management").UnprocessableEntity, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    delete: ({ output }: {
+        output: ModelAttributes;
+    }) => Effect.Effect<void, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/litellm/model_management").BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("./model-errors.ts").LitellmModelUnreadableError | 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/model_management").UnprocessableEntity, 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 LiteLLMModelProvider: () => import("effect/Layer").Layer<Provider.Provider<LiteLLMModel>, never, import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/litellm/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EACL,iCAAiC,EACjC,8BAA8B,EAC9B,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAY3B,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEpE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,YAAa,SAAQ,QAAQ,CAAC,eAAe,EAAE,UAAU,EAAE,eAAe,CAAC;CAAG;AAE/F,eAAO,MAAM,YAAY,+CAEvB,CAAC;AAEH,eAAO,MAAM,cAAc,UAAW,OAAO,KAAG,KAAK,IAAI,YACe,CAAC;AASzE,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC;CACrC,GAAG,CAAC,CAAC;AAEN,oDAAoD;AACpD,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;IACH,IAAI,qCAAqC,IAAI,CAAC;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC;IA4BnE,IAAI,kCAID;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QACxB,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC;KACrC;yBASsB,SAAS;;;;yBAYb,MAAM;;;yBACN,QAAQ;;IAG3B,SAAS,0CAA0C,IAAI,CAAC;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC;;;;;;;;;;IAiF7E,MAAM,eAAe;QAAE,MAAM,EAAE,eAAe,CAAA;KAAE;IAEhD,mGAAmG;IACnG,IAAI;CACL,CAAC;AAEF,eAAO,MAAM,oBAAoB,8LACuD,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * Wire bodies, comparison and refusals for `LiteLLM.PolicyAttachment`, testable without a server.
+ *
+ * ★ TWO ATTACHMENTS ARE "THE SAME" WHEN EVERY FIELD IS: the policy, the scope, the four selector SETS
+ *   and the priority. That is the only identity an attachment has (policy-attachment-types.ts), and
+ *   it is what adoption and the read back both use.
+ */
+import type * as policies from '@distilled.cloud/litellm/policy_engine';
+import type { PolicyAttachmentAttributes, PolicyAttachmentProps } from './policy-attachment-types.ts';
+/** The first reason a declaration is refused, or `undefined`. Runs before any request. */
+export declare const firstProblem: (props: PolicyAttachmentProps) => string | undefined;
+/** One attachment row. `undefined` is "not an attachment", and so is a config-file one. */
+export declare const toAttributes: (value: unknown) => PolicyAttachmentAttributes | undefined;
+/** Whether a live row is defined in config.yaml (its synthetic id is `config-<n>`): out of reach of the API. */
+export declare const isConfigRow: (value: unknown) => boolean;
+/** Wire names of the fields where live and declared disagree. Empty means "the same attachment". */
+export declare const differing: (live: PolicyAttachmentAttributes, props: PolicyAttachmentProps) => readonly string[];
+export declare const createBody: (props: PolicyAttachmentProps) => policies.CreatePolicyAttachmentPoliciesAttachmentsPostRequest;
+//# sourceMappingURL=policy-attachment-form.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"policy-attachment-form.d.ts","sourceRoot":"","sources":["../../src/litellm/policy-attachment-form.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,KAAK,QAAQ,MAAM,wCAAwC,CAAC;AAYxE,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,8BAA8B,CAAC;AAItC,0FAA0F;AAC1F,eAAO,MAAM,YAAY,UAAW,qBAAqB,KAAG,MAAM,GAAG,SA2BpE,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,YAAY,UAAW,OAAO,KAAG,0BAA0B,GAAG,SAgB1E,CAAC;AAEF,gHAAgH;AAChH,eAAO,MAAM,WAAW,UAAW,OAAO,KAAG,OACO,CAAC;AAErD,oGAAoG;AACpG,eAAO,MAAM,SAAS,SACd,0BAA0B,SACzB,qBAAqB,KAC3B,SAAS,MAAM,EAOjB,CAAC;AAEF,eAAO,MAAM,UAAU,UACd,qBAAqB,KAC3B,QAAQ,CAAC,oDAQV,CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * The three LiteLLM `/policies/attachments*` calls `LiteLLM.PolicyAttachment` uses, through the SDK's
+ * typed operations in `@distilled.cloud/litellm/policy_engine` (LiteLLM 1.103.0):
+ *
+ *   list    `listPolicyAttachmentsPoliciesAttachmentsListGet`             GET    /policies/attachments/list
+ *   create  `createPolicyAttachmentPoliciesAttachmentsPost`              POST   /policies/attachments
+ *   delete  `deletePolicyAttachmentPoliciesAttachmentsAttachmentIdDelete` DELETE /policies/attachments/{id}
+ *
+ * ★ THERE IS NO UPDATE OPERATION, because the API has none (policy-attachment-types.ts). The by-id
+ *   `GET` is not used either: the list carries every field and answers absence without a 404.
+ * ★ THE LIST MERGES IN CONFIG-FILE ATTACHMENTS (`definition_location: "config"`, ids `config-<n>`),
+ *   which the API cannot delete. `listAttachments` returns database rows only.
+ * ⚠️ MOST FAILURES ARE A PLAIN 500 (`policy_endpoints.py` wraps everything in `except Exception` and
+ *   answers `HTTPException(500, detail=str(e))`), and the SDK retries 5xx with backoff. The two
+ *   answers that are not: a policy with no production version is a 404, and a concrete team, key or model
+ *   selector that resolves to nothing is a 400 (`PolicyValidator.find_invalid_scope_entries`), so a
+ *   `teams` entry must exist BEFORE its attachment: declare it as `team.teamAlias`. Wildcard patterns
+ *   are let through, and may match nothing today.
+ * ★ DELETE IS IDEMPOTENT BY A REAL READ: a failed DELETE (a missing id is a 404) is swallowed only when
+ *   the list no longer has the id; otherwise the ORIGINAL error is re-raised.
+ */
+import * as policies from '@distilled.cloud/litellm/policy_engine';
+import * as Effect from 'effect/Effect';
+import type { PolicyAttachmentAttributes } from './policy-attachment-types.ts';
+import { LitellmRegistryUnreadableError } from './registry-errors.ts';
+/** Every DATABASE attachment. Config-file ones are dropped here, once. */
+export declare const listAttachments: () => Effect.Effect<readonly PolicyAttachmentAttributes[], LitellmRegistryUnreadableError | policies.LitellmOpError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+/** The created row, which carries the id LiteLLM issued. `undefined` when the answer is not one. */
+export declare const createAttachment: (body: policies.CreatePolicyAttachmentPoliciesAttachmentsPostRequest) => Effect.Effect<PolicyAttachmentAttributes | undefined, policies.CreatePolicyAttachmentPoliciesAttachmentsPostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const deleteAttachment: (attachmentId: string) => Effect.Effect<void, policies.DeletePolicyAttachmentPoliciesAttachmentsAttachmentIdDeleteError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+//# sourceMappingURL=policy-attachment-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"policy-attachment-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/policy-attachment-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,QAAQ,MAAM,wCAAwC,CAAC;AACnE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAQtE,0EAA0E;AAC1E,eAAO,MAAM,eAAe,kLAWzB,CAAC;AAEJ,oGAAoG;AACpG,eAAO,MAAM,gBAAgB,SACrB,QAAQ,CAAC,oDAAoD,mLAIlE,CAAC;AAEJ,eAAO,MAAM,gBAAgB,iBAAkB,MAAM,+JAiBlD,CAAC"}