@homeflare/alchemy 0.42.0 → 0.44.0

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

@@ -0,0 +1,26 @@
+/**
+ * Wire bodies, comparison and refusals for `LiteLLM.AccessGroup`, testable without a server.
+ *
+ * ★ THE UPDATE IS A PARTIAL ONE, so it sends only what differs. `update_access_group` builds its
+ *   write from `data.model_dump(exclude_unset=True)` (`access_group_endpoints.py`, 1.103.0), and turns
+ *   a `null` list into `[]`. Nothing here relies on an omitted field being kept beyond that rule.
+ * ★ THE ROW READ BACK IS THE WHOLE TABLE, through `GET /v1/unified_access_group`. That route has no
+ *   filter and no by-name form, and it answers absence unambiguously, which a by-id `GET` (a 404 the
+ *   SDK does not declare for this tag) does not.
+ */
+import type * as ag from '@distilled.cloud/litellm/access_groups';
+import type { AccessGroupAttributes, AccessGroupProps } from './access-group-types.ts';
+/** The first reason a declaration is refused, or `undefined`. Runs before any request. */
+export declare const firstProblem: (props: AccessGroupProps) => string | undefined;
+/** One row of the list. `undefined` is "not a row": the caller refuses the whole answer. */
+export declare const toAttributes: (value: unknown) => AccessGroupAttributes | undefined;
+/**
+ * Wire names of the fields where live and declared disagree. The description counts only when
+ * declared; the two grant lists always count, an undeclared one meaning "grants nothing".
+ */
+export declare const differing: (live: AccessGroupAttributes, props: AccessGroupProps) => readonly string[];
+/** Create body: the name and both grant lists always (a create with none would be an empty group). */
+export declare const createBody: (props: AccessGroupProps) => ag.CreateAccessGroupV1UnifiedAccessGroupPostRequest;
+/** Update body: only the fields that differ, so nothing the declaration does not manage is sent. */
+export declare const updateBody: (props: AccessGroupProps, live: AccessGroupAttributes) => Omit<ag.UpdateAccessGroupV1UnifiedAccessGroupAccessGroupIdPutRequest, 'access_group_id'>;
+//# sourceMappingURL=access-group-form.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"access-group-form.d.ts","sourceRoot":"","sources":["../../src/litellm/access-group-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,EAAE,MAAM,wCAAwC,CAAC;AAWlE,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEvF,0FAA0F;AAC1F,eAAO,MAAM,YAAY,UAAW,gBAAgB,KAAG,MAAM,GAAG,SAkB/D,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,YAAY,UAAW,OAAO,KAAG,qBAAqB,GAAG,SAarE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,SACd,qBAAqB,SACpB,gBAAgB,KACtB,SAAS,MAAM,EASjB,CAAC;AAEF,sGAAsG;AACtG,eAAO,MAAM,UAAU,UACd,gBAAgB,KACtB,EAAE,CAAC,gDAKJ,CAAC;AAEH,oGAAoG;AACpG,eAAO,MAAM,UAAU,UACd,gBAAgB,QACjB,qBAAqB,KAC1B,IAAI,CAAC,EAAE,CAAC,4DAA4D,EAAE,iBAAiB,CAYzF,CAAC"}

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

@@ -0,0 +1,37 @@
+/**
+ * The four LiteLLM `/v1/unified_access_group*` calls `LiteLLM.AccessGroup` uses, through the SDK's
+ * typed operations in `@distilled.cloud/litellm/access_groups` (LiteLLM 1.103.0):
+ *
+ *   list    `listAccessGroupsV1UnifiedAccessGroupGet`                     GET    /v1/unified_access_group
+ *   create  `createAccessGroupV1UnifiedAccessGroupPost`                   POST   /v1/unified_access_group
+ *   update  `updateAccessGroupV1UnifiedAccessGroupAccessGroupIdPut`       PUT    /v1/unified_access_group/{id}
+ *   delete  `deleteAccessGroupV1UnifiedAccessGroupAccessGroupIdDelete`    DELETE /v1/unified_access_group/{id}
+ *
+ * `/v1/unified_access_group` is registered as an alias of `/v1/access_group` on the same handlers
+ * (`access_group_endpoints.py`, the "Alias routes" block), so the two answer identically.
+ * The by-id `GET` is not used: a missing id is a 404 this tag does not declare, and the list decides
+ * absence without depending on it.
+ *
+ * ⛔ WRITES NEED PROXY_ADMIN (`_require_proxy_admin`, 403 otherwise) and READS need admin or admin-view
+ *   (`_require_admin_view`). A key that can only read sees every group and can change none.
+ * ⛔ NO MESSAGE SNIFFING. Nothing here reads a status or message. `create` of a name that exists is a
+ *   409 LiteLLM raises itself; the SDK does not declare it for this tag, so it reaches the caller as
+ *   the SDK's own error, unchanged. `create` runs only after a list showed the name absent, so a 409
+ *   means a concurrent create, which is a failure to report, not to paper over.
+ * ★ DELETE IS IDEMPOTENT BY A REAL READ (the budget and pass-through rule): a failed DELETE is
+ *   swallowed only when the list no longer has the id. A 403 for lack of rights leaves the row
+ *   live, so it re-raises the ORIGINAL error.
+ * ⚠️ DELETING A GROUP DETACHES IT FROM EVERY TEAM AND KEY (`delete_access_group` rewrites their
+ *   `access_group_ids`), which is why the resource defaults to `retain`.
+ */
+import * as ag from '@distilled.cloud/litellm/access_groups';
+import * as Effect from 'effect/Effect';
+import { type LitellmOpContext } from './operations.ts';
+import { LitellmRegistryUnreadableError } from './registry-errors.ts';
+import { type AccessGroupAttributes } from './access-group-types.ts';
+/** Every group. The list is the table (`AccessGroupRepository(...).table.find_many`), not a registry. */
+export declare const listAccessGroups: () => Effect.Effect<readonly AccessGroupAttributes[], ag.ListAccessGroupsV1UnifiedAccessGroupGetError | LitellmRegistryUnreadableError, LitellmOpContext>;
+export declare const createAccessGroup: (body: ag.CreateAccessGroupV1UnifiedAccessGroupPostRequest) => Effect.Effect<void, ag.CreateAccessGroupV1UnifiedAccessGroupPostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const updateAccessGroup: (accessGroupId: string, body: Omit<ag.UpdateAccessGroupV1UnifiedAccessGroupAccessGroupIdPutRequest, 'access_group_id'>) => Effect.Effect<void, ag.UpdateAccessGroupV1UnifiedAccessGroupAccessGroupIdPutError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const deleteAccessGroup: (accessGroupId: string) => Effect.Effect<void, ag.DeleteAccessGroupV1UnifiedAccessGroupAccessGroupIdDeleteError, LitellmOpContext>;
+//# sourceMappingURL=access-group-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"access-group-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/access-group-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,MAAM,wCAAwC,CAAC;AAC7D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAKrE,yGAAyG;AACzG,eAAO,MAAM,gBAAgB,QAAO,MAAM,CAAC,MAAM,CAC/C,SAAS,qBAAqB,EAAE,EAChC,EAAE,CAAC,4CAA4C,GAAG,8BAA8B,EAChF,gBAAgB,CAoBf,CAAC;AAEJ,eAAO,MAAM,iBAAiB,SAAU,EAAE,CAAC,gDAAgD,uIACL,CAAC;AAEvF,eAAO,MAAM,iBAAiB,kBACb,MAAM,QACf,IAAI,CAAC,EAAE,CAAC,4DAA4D,EAAE,iBAAiB,CAAC,mJAOzE,CAAC;AAExB,eAAO,MAAM,iBAAiB,kBAAmB,MAAM,4GAepD,CAAC"}

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

@@ -0,0 +1,49 @@
+/**
+ * What a `LiteLLM.AccessGroup` declares (props) and what is remembered about it (attributes).
+ *
+ * ★ THIS IS THE UNIFIED ACCESS GROUP, `LiteLLM_AccessGroupTable` (`/v1/unified_access_group`), not
+ *   the two other things LiteLLM calls an "access group": a MODEL access group (`access_groups` in a
+ *   model's `model_info`) and an MCP access group (a bare name on an MCP server row, referenced by
+ *   `object_permission.mcp_access_groups`). A unified group bundles models, MCP servers and agents
+ *   under one name and attaches to teams and keys (docs.litellm.ai/docs/proxy/access_groups).
+ * ⚠️ TOOLSETS ARE NOT IN IT. `AccessGroupCreateRequest` (`litellm/types/access_group.py`, 1.103.0)
+ *   has `access_model_names`, `access_mcp_server_ids`, `access_agent_ids`, `assigned_team_ids` and
+ *   `assigned_key_ids` and no toolset field. A toolset is granted through `object_permission.mcp_toolsets`
+ *   on a team or key (`LiteLLM.Team`), not through a group.
+ * ★ MODELS ARE MODEL NAMES, MCP SERVERS ARE SERVER IDS. `access_model_names` holds the `model_name`
+ *   a caller sends (`cf-code`), and `access_mcp_server_ids` holds `server_id`s. Declare a server's id
+ *   with `server.serverId` (a `LiteLLM.MCPServer`) so the dependency edge exists.
+ * ⚠️ NOT MODELLED, on purpose: `assigned_team_ids`, `assigned_key_ids` and `access_agent_ids`. A
+ *   team's group membership is declared on the TEAM (`accessGroupIds`), and LiteLLM mirrors it into
+ *   `assigned_team_ids` in the same transaction; two resources writing one edge would fight. Agents
+ *   are not managed here. None of the three is ever sent, and the update is a partial one, so an
+ *   adopted group keeps whatever it has there.
+ */
+export interface AccessGroupProps {
+    /**
+     * The group's name, and the way an existing row is ADOPTED: `access_group_name` is UNIQUE in the
+     * table (`access_group_endpoints.py` finds it with `find_unique`), so the match is exact. Changing
+     * it is an update of the same row, never a replace: the id does not change.
+     */
+    readonly accessGroupName: string;
+    /** Compared only when declared: adopting a row never clears text a person wrote. Blank is refused. */
+    readonly description?: string;
+    /**
+     * `model_name`s the group grants, compared as a SET and ALWAYS compared (default `[]`): it is an
+     * access grant, so an adopted group that grants more than declared is corrected, never left open.
+     * ⚠️ LiteLLM prunes a name itself when its last deployment is deleted
+     * (`management_helpers/access_group_model_sync.py`), so a plan can show an update for a model that
+     * was removed elsewhere.
+     */
+    readonly modelNames?: readonly string[];
+    /** MCP `server_id`s the group grants, compared as a set and always compared (default `[]`). */
+    readonly mcpServerIds?: readonly string[];
+}
+export interface AccessGroupAttributes {
+    readonly accessGroupId: string;
+    readonly accessGroupName: string;
+    readonly description: string | null;
+    readonly modelNames: readonly string[];
+    readonly mcpServerIds: readonly string[];
+}
+//# sourceMappingURL=access-group-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"access-group-types.d.ts","sourceRoot":"","sources":["../../src/litellm/access-group-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,sGAAsG;IACtG,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,+FAA+F;IAC/F,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C"}

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

@@ -0,0 +1,55 @@
+/**
+ * `LiteLLM.AccessGroup` — one row of LiteLLM's unified access group table
+ * (`LiteLLM_AccessGroupTable`, `/v1/unified_access_group`): a named bundle of models and MCP servers
+ * that teams and keys are attached to. Types and what is left out: access-group-types.ts.
+ *
+ * ★ ADOPT BY NAME. `access_group_name` is unique in the table, so `accessGroupName` finds the one
+ *   live row that carries it. A live row with no state is `Unowned`, so it needs `--adopt`.
+ * ★ `defaultRemovalPolicy: 'retain'` — deleting a group detaches it from every team and key that
+ *   holds it (`delete_access_group` rewrites their `access_group_ids`), and those callers lose the
+ *   models and servers it granted. Opt in with `.pipe(RemovalPolicy.destroy())`.
+ * ★ THE GRANTS ARE THE DECLARATION. `modelNames` and `mcpServerIds` are always compared (an
+ *   undeclared list means "grants nothing"), so an adopted group that grants more is corrected.
+ * ⚠️ NO LICENCE GATE ON THESE ROUTES: `access_group_endpoints.py` has no `premium_user` check
+ *   (grep, 1.103.0), and docs.litellm.ai/docs/proxy/access_groups makes no Enterprise statement.
+ * ⛔ NO LITELLM CREDENTIAL IS A PROP; `litellmProviders`' layer supplies `Credentials`.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import type { AccessGroupAttributes, AccessGroupProps } from './access-group-types.ts';
+import { LitellmRegistryAbsentAfterWriteError, LitellmRegistryNotConvergedError } from './registry-errors.ts';
+export type { AccessGroupAttributes, AccessGroupProps };
+export type { RegistryError as AccessGroupError } from './registry-errors.ts';
+export interface LiteLLMAccessGroup extends Resource<'LiteLLM.AccessGroup', AccessGroupProps, AccessGroupAttributes> {
+}
+export declare const LiteLLMAccessGroup: import("alchemy").ResourceClass<LiteLLMAccessGroup>;
+export declare const isLiteLLMAccessGroup: (value: unknown) => value is LiteLLMAccessGroup;
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export declare const accessGroupHandlers: {
+    /** ⛔ With no `output` this is the adoption probe, so the refusals run here too (registry-support.ts). */
+    read: ({ olds, output }: {
+        olds: AccessGroupProps;
+        output: AccessGroupAttributes | undefined;
+    }) => Effect.Effect<AccessGroupAttributes | undefined, import("./registry-errors.ts").LitellmRegistryUnreadableError | import("@distilled.cloud/litellm/Protocol").LitellmOpError, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    diff: ({ news, output, }: {
+        news: Input<AccessGroupProps>;
+        output: AccessGroupAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'noop';
+    } | {
+        readonly action: 'update';
+    } | undefined, import("./registry-errors.ts").LitellmRegistryInvalidError, never>;
+    reconcile: ({ news, output, }: {
+        news: AccessGroupProps;
+        output: AccessGroupAttributes | undefined;
+    }) => Effect.Effect<AccessGroupAttributes, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("@distilled.cloud/litellm/Errors").LitellmParseError | LitellmRegistryAbsentAfterWriteError | import("./registry-errors.ts").LitellmRegistryInvalidError | LitellmRegistryNotConvergedError | import("./registry-errors.ts").LitellmRegistryUnreadableError | 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/access_groups").UnprocessableEntity, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    delete: ({ output }: {
+        output: AccessGroupAttributes;
+    }) => Effect.Effect<void, import("@distilled.cloud/litellm/access_groups").DeleteAccessGroupV1UnifiedAccessGroupAccessGroupIdDeleteError, 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 LiteLLMAccessGroupProvider: () => import("effect/Layer").Layer<Provider.Provider<LiteLLMAccessGroup>, never, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=access-group.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"access-group.d.ts","sourceRoot":"","sources":["../../src/litellm/access-group.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;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;AASxC,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACvF,OAAO,EACL,oCAAoC,EACpC,gCAAgC,EACjC,MAAM,sBAAsB,CAAC;AAG9B,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAC;AACxD,YAAY,EAAE,aAAa,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI9E,MAAM,WAAW,kBAAmB,SAAQ,QAAQ,CAClD,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,CACtB;CAAG;AAEJ,eAAO,MAAM,kBAAkB,qDAE7B,CAAC;AAEH,eAAO,MAAM,oBAAoB,UAAW,OAAO,KAAG,KAAK,IAAI,kBACe,CAAC;AAgB/E,oDAAoD;AACpD,eAAO,MAAM,mBAAmB;IAC9B,yGAAyG;IACzG,IAAI,qBAAqB;QAAE,IAAI,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAA;KAAE;IAU9F,IAAI,sBAGD;QACD,IAAI,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC9B,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;KAC3C;yBAMkB,MAAM;;yBACN,QAAQ;;IAG3B,SAAS,sBAGN;QACD,IAAI,EAAE,gBAAgB,CAAC;QACvB,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;KAC3C;IAmCD,MAAM,eAAe;QAAE,MAAM,EAAE,qBAAqB,CAAA;KAAE;IAGtD,mGAAmG;IACnG,IAAI;CACL,CAAC;AAEF,eAAO,MAAM,0BAA0B,gJAIpC,CAAC"}

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

@@ -0,0 +1,36 @@
+/**
+ * The typed refusals `LiteLLM.Budget` raises on top of `@distilled.cloud/litellm`'s own SDK errors.
+ */
+import type * as budgets from '@distilled.cloud/litellm/budget_management';
+declare const LitellmBudgetHardCapUnjustifiedError_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: "LitellmBudgetHardCapUnjustifiedError";
+} & Readonly<A>;
+/** A `maxBudget` (a HARD cap: LiteLLM answers 429 once it is spent) declared with no reason. */
+export declare class LitellmBudgetHardCapUnjustifiedError extends LitellmBudgetHardCapUnjustifiedError_base<{
+    readonly budgetId: string | undefined;
+}> {
+}
+declare const LitellmBudgetFieldNotClearedError_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: "LitellmBudgetFieldNotClearedError";
+} & Readonly<A>;
+/**
+ * The write returned no error but the row still carries a limit the declaration does not.
+ * `/budget/update` may merge with `exclude_none` (the way `/config/pass_through_endpoint` does),
+ * in which case a limit can never be cleared by an update. Refused, never claimed as done.
+ */
+export declare class LitellmBudgetFieldNotClearedError extends LitellmBudgetFieldNotClearedError_base<{
+    readonly budgetId: string;
+    readonly fields: readonly string[];
+}> {
+}
+declare const LitellmBudgetUnreadableError_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: "LitellmBudgetUnreadableError";
+} & Readonly<A>;
+/** `/budget/info` answered something that is not a list of budget rows. */
+export declare class LitellmBudgetUnreadableError extends LitellmBudgetUnreadableError_base<{
+    readonly budgetId: string;
+}> {
+}
+export type BudgetError = budgets.PostInfoBudgetBudgetInfoError | budgets.PostNewBudgetBudgetNewError | budgets.UpdateBudgetBudgetUpdatePostError | budgets.DeleteBudgetBudgetDeletePostError | LitellmBudgetHardCapUnjustifiedError | LitellmBudgetFieldNotClearedError | LitellmBudgetUnreadableError;
+export {};
+//# sourceMappingURL=budget-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"budget-errors.d.ts","sourceRoot":"","sources":["../../src/litellm/budget-errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,4CAA4C,CAAC;;;;AAG3E,gGAAgG;AAChG,qBAAa,oCAAqC,SAAQ,0CAExD;IACA,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC,CAAC;CAAG;;;;AAEL;;;;GAIG;AACH,qBAAa,iCAAkC,SAAQ,uCAErD;IACA,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;CAAG;;;;AAEL,2EAA2E;AAC3E,qBAAa,4BAA6B,SAAQ,kCAAiD;IACjG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;CAAG;AAEL,MAAM,MAAM,WAAW,GACnB,OAAO,CAAC,6BAA6B,GACrC,OAAO,CAAC,2BAA2B,GACnC,OAAO,CAAC,iCAAiC,GACzC,OAAO,CAAC,iCAAiC,GACzC,oCAAoC,GACpC,iCAAiC,GACjC,4BAA4B,CAAC"}

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

@@ -0,0 +1,50 @@
+/**
+ * Props, wire bodies and comparison for `LiteLLM.Budget`, testable without a server.
+ *
+ * ⛔ NO SILENT `max_budget`. LiteLLM's own field doc: "Requests will fail if this budget (in USD)
+ *   is exceeded" — a hard cap. On 2026-09-28 an undeclared $60/day `max_budget` on
+ *   `hf-tier-interactive` 429'd the whole claude2 fleet. So `maxBudget` is never defaulted and is
+ *   refused unless `maxBudgetReason` says why; `softBudget` is the monitoring field (it "will NOT
+ *   fail if this is exceeded", it fires the alert).
+ * ⚠️ NOT MODELLED: `max_parallel_requests`, `model_max_budget`, `budget_reset_at`. The row read
+ *   back (`BudgetListItem`, generated at LiteLLM 1.100.0) has none of them, so a declaration of
+ *   them could never be diffed. Add them when a read that returns them is measured.
+ */
+import type * as budgets from '@distilled.cloud/litellm/budget_management';
+export interface BudgetProps {
+    /** Live budget id. Set it to adopt an existing row (`hf-tier-agent`); default is a deterministic physical name. */
+    readonly budgetId?: string;
+    /** Alert threshold in USD. Requests keep flowing when exceeded. The monitoring field. */
+    readonly softBudget?: number;
+    /** HARD cap in USD: requests fail (429) once spent. Refused unless `maxBudgetReason` is set. */
+    readonly maxBudget?: number;
+    /** Why a hard cap is wanted. Required with `maxBudget`; recorded in the declaration only. */
+    readonly maxBudgetReason?: string;
+    /** Reset period, e.g. `'1d'`, `'28d'`. */
+    readonly budgetDuration?: string;
+    /** Requests per minute. */
+    readonly rpmLimit?: number;
+    /** Tokens per minute. */
+    readonly tpmLimit?: number;
+}
+export interface BudgetAttributes {
+    readonly budgetId: string;
+    readonly softBudget: number | null;
+    readonly maxBudget: number | null;
+    readonly budgetDuration: string | null;
+    readonly rpmLimit: number | null;
+    readonly tpmLimit: number | null;
+}
+export declare const isHardCapUnjustified: (props: BudgetProps) => boolean;
+/** Create body: only what is declared. */
+export declare const createBody: (props: BudgetProps, budgetId: string) => budgets.PostNewBudgetBudgetNewRequest;
+/** Update body: declared fields, plus an explicit `null` for a live limit the declaration dropped. */
+export declare const updateBody: (props: BudgetProps, live: BudgetAttributes) => budgets.UpdateBudgetBudgetUpdatePostRequest;
+/** Wire names of the fields where live and declared disagree. */
+export declare const differing: (live: BudgetAttributes, props: BudgetProps) => readonly string[];
+/**
+ * One row of `/budget/info`. `tpm_limit`/`rpm_limit` are `BigInt?` in LiteLLM's schema and come
+ * back as decimal strings (the generated `BudgetListItem` says so), hence `Number()`.
+ */
+export declare const toAttributes: (row: Record<string, unknown>) => BudgetAttributes;
+//# sourceMappingURL=budget-form.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"budget-form.d.ts","sourceRoot":"","sources":["../../src/litellm/budget-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,4CAA4C,CAAC;AAE3E,MAAM,WAAW,WAAW;IAC1B,mHAAmH;IACnH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,gGAAgG;IAChG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6FAA6F;IAC7F,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,0CAA0C;IAC1C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,yBAAyB;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAWD,eAAO,MAAM,oBAAoB,UAAW,WAAW,KAAG,OACoB,CAAC;AAE/E,0CAA0C;AAC1C,eAAO,MAAM,UAAU,UACd,WAAW,YACR,MAAM,KACf,OAAO,CAAC,6BAIV,CAAC;AAEF,sGAAsG;AACtG,eAAO,MAAM,UAAU,UACd,WAAW,QACZ,gBAAgB,KACrB,OAAO,CAAC,mCAOV,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,SAAS,SAAU,gBAAgB,SAAS,WAAW,KAAG,SAAS,MAAM,EACG,CAAC;AAK1F;;;GAGG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,gBAO1D,CAAC"}

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

@@ -0,0 +1,20 @@
+/**
+ * The four LiteLLM `/budget/*` calls `LiteLLM.Budget` uses, through the SDK's typed operations.
+ *
+ * ★ READS GO THROUGH `/budget/list` (the whole table, a bare array), not `/budget/info`. Both
+ *   answer `body: unknown` in the generated schema, and what `/budget/info` does for an id that is
+ *   not there is unmeasured; a list answers absence unambiguously.
+ * ⚠️ Unlike pass-through endpoints, each budget is its own DB row, so no semaphore.
+ * ⚠️ DELETE is idempotent BY THIS FUNCTION: a `BadRequest` re-lists and is swallowed only when the
+ *   id is genuinely absent, never on message text (pass-through `operations.ts`' rule).
+ */
+import * as budgets from '@distilled.cloud/litellm/budget_management';
+import * as Effect from 'effect/Effect';
+import { type LitellmOpContext } from './operations.ts';
+import { type BudgetAttributes } from './budget-form.ts';
+import { LitellmBudgetUnreadableError } from './budget-errors.ts';
+export declare const listBudgets: () => Effect.Effect<readonly BudgetAttributes[], budgets.ListBudgetBudgetListGetError | LitellmBudgetUnreadableError, LitellmOpContext>;
+export declare const createBudget: (body: budgets.PostNewBudgetBudgetNewRequest) => Effect.Effect<void, budgets.PostNewBudgetBudgetNewError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const updateBudget: (body: budgets.UpdateBudgetBudgetUpdatePostRequest) => Effect.Effect<void, budgets.UpdateBudgetBudgetUpdatePostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const deleteBudget: (id: string) => Effect.Effect<void, import("@distilled.cloud/caddy").BadGateway | budgets.BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | LitellmBudgetUnreadableError | 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 | budgets.UnprocessableEntity, LitellmOpContext>;
+//# sourceMappingURL=budget-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"budget-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/budget-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,OAAO,MAAM,4CAA4C,CAAC;AACtE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,WAAW,QAAO,MAAM,CAAC,MAAM,CAC1C,SAAS,gBAAgB,EAAE,EAC3B,OAAO,CAAC,4BAA4B,GAAG,4BAA4B,EACnE,gBAAgB,CAaf,CAAC;AAEJ,eAAO,MAAM,YAAY,SAAU,OAAO,CAAC,6BAA6B,yHACA,CAAC;AAEzE,eAAO,MAAM,YAAY,SAAU,OAAO,CAAC,mCAAmC,+HACA,CAAC;AAE/E,eAAO,MAAM,YAAY,OAAQ,MAAM,ypBAUpC,CAAC"}

package/dist/litellm/budget.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `LiteLLM.Budget` — one row of LiteLLM's `LiteLLM_BudgetTable` (`/budget/*`), the "tier" keys and
+ * teams bind to (`hf-tier-*`).
+ *
+ * ★ MONITORING, NOT LIMITS (Tim, 2026-09-28): `softBudget` is the prop; `maxBudget` is a hard cap
+ *   that 429s every caller and is refused without `maxBudgetReason` (budget-form.ts).
+ * ★ ADOPT BY id. `budgetId` names the live row; without it a deterministic physical name is used.
+ *   A foreign row with that id is `Unowned`, so it needs `--adopt`.
+ * ★ `defaultRemovalPolicy: 'retain'` — deleting a budget row that keys still reference either
+ *   fails or detaches them, and a detached key loses its rate limits. Opt in with
+ *   `.pipe(RemovalPolicy.destroy())`.
+ * ⛔ CLEARING A LIMIT: sent as an explicit `null`. If this LiteLLM merges with `exclude_none` the
+ *   row keeps the old value; reconcile reads back and FAILS (`LitellmBudgetFieldNotClearedError`)
+ *   rather than report a cleared cap. Unmeasured against a live proxy at 1.103.0.
+ * ⛔ NO CREDENTIAL IS A PROP; `litellmProviders`' layer supplies `Credentials`.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import { LitellmBudgetFieldNotClearedError, LitellmBudgetHardCapUnjustifiedError } from './budget-errors.ts';
+import { type BudgetAttributes, type BudgetProps } from './budget-form.ts';
+export type { BudgetAttributes, BudgetProps };
+export type { BudgetError } from './budget-errors.ts';
+export interface LiteLLMBudget extends Resource<'LiteLLM.Budget', BudgetProps, BudgetAttributes> {
+}
+export declare const LiteLLMBudget: import("alchemy").ResourceClass<LiteLLMBudget>;
+export declare const isLiteLLMBudget: (value: unknown) => value is LiteLLMBudget;
+type Args<P> = {
+    id: string;
+    instanceId: string;
+    output: BudgetAttributes | undefined;
+} & P;
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export declare const budgetHandlers: {
+    read: ({ id, instanceId, olds, output }: Args<{
+        olds: BudgetProps;
+    }>) => Effect.Effect<BudgetAttributes | undefined, import("./budget-errors.ts").LitellmBudgetUnreadableError | import("@distilled.cloud/litellm/budget_management").ListBudgetBudgetListGetError, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    diff: ({ news, output }: {
+        news: Input<BudgetProps>;
+        output: BudgetAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'replace';
+        readonly deleteFirst: false;
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'noop';
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'update';
+    } | undefined, LitellmBudgetHardCapUnjustifiedError, never>;
+    reconcile: ({ id, instanceId, news, output }: Args<{
+        news: BudgetProps;
+    }>) => Effect.Effect<BudgetAttributes, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/litellm/budget_management").BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | LitellmBudgetFieldNotClearedError | LitellmBudgetHardCapUnjustifiedError | import("./budget-errors.ts").LitellmBudgetUnreadableError | 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/budget_management").UnprocessableEntity, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    delete: ({ output }: {
+        output: BudgetAttributes;
+    }) => Effect.Effect<void, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/litellm/budget_management").BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("./budget-errors.ts").LitellmBudgetUnreadableError | 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/budget_management").UnprocessableEntity, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    list: () => Effect.Effect<never[], never, never>;
+};
+export declare const LiteLLMBudgetProvider: () => import("effect/Layer").Layer<Provider.Provider<LiteLLMBudget>, never, import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=budget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/litellm/budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;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;AAExC,OAAO,EACL,iCAAiC,EACjC,oCAAoC,EACrC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,CAAC;AAC9C,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,WAAW,aAAc,SAAQ,QAAQ,CAAC,gBAAgB,EAAE,WAAW,EAAE,gBAAgB,CAAC;CAAG;AAEnG,eAAO,MAAM,aAAa,gDAExB,CAAC;AAEH,eAAO,MAAM,eAAe,UAAW,OAAO,KAAG,KAAK,IAAI,aACe,CAAC;AAmB1E,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACtC,GAAG,CAAC,CAAC;AAEN,oDAAoD;AACpD,eAAO,MAAM,cAAc;IACzB,IAAI,qCAAqC,IAAI,CAAC;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC;IAQpE,IAAI,qBAAqB;QAAE,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAA;KAAE;yBAOpE,SAAS;;;;yBAGb,MAAM;;;yBACN,QAAQ;;IAG3B,SAAS,qCAAqC,IAAI,CAAC;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC;IAuBzE,MAAM,eAAe;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE;IAEjD,IAAI;CACL,CAAC;AAEF,eAAO,MAAM,qBAAqB,+LACyD,CAAC"}

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

@@ -0,0 +1,131 @@
+/**
+ * The typed refusals `LiteLLM.Credential` raises on top of `@distilled.cloud/litellm`'s own SDK
+ * errors.
+ *
+ * ⛔ NO MESSAGE HERE MAY CARRY A CREDENTIAL VALUE: only the credential's NAME, field names, the
+ *   NAMES of environment variables, and SDK error text — exactly like mcp-server-errors.ts.
+ * ⚠️ THE SDK'S TYPED UNION IS NARROW ON PURPOSE, and the runtime is wider: the credential routes
+ *   declare only `UnprocessableEntity` (422) in `credential_management.ts`, so a create on an
+ *   existing name — which the live 1.103.0 container answers `409` (`endpoints.py`'s
+ *   `_credential_exists_detail`) — decodes at run time as the core `Conflict` class (`Errors.ts`
+ *   re-exports it, but it is not in the operation's TS union) and PROPAGATES as such, never
+ *   silently swallowed (S21). The read's and delete's `404` is TYPED as the SDK's
+ *   `CredentialNotFound` (a distilled patch matched on the vendor's "Credential not found"
+ *   message, `endpoints.py`), so credential-operations.ts `catchTag`s it instead of `instanceof`
+ *   `NotFound`: a 404 from a front proxy, Access, or a wrong base path stays a `NotFound` and is
+ *   never read as absence. `CredentialError` carries the typed members of the four operations the
+ *   resource calls (create, by-name read, PATCH, delete), plus the refusals below.
+ */
+import type * as credentials from '@distilled.cloud/litellm/credential_management';
+import type { HttpClientErrorReason } from 'effect/unstable/http/HttpClientError';
+declare const LitellmCredentialInvalidError_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: "LitellmCredentialInvalidError";
+} & Readonly<A>;
+/** A declaration the resource refuses before any request: a combination nobody meant. */
+export declare class LitellmCredentialInvalidError extends LitellmCredentialInvalidError_base<{
+    readonly credentialName: string;
+    readonly problem: string;
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialTransportError_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: "LitellmCredentialTransportError";
+} & Readonly<A>;
+/**
+ * A create's `POST /credentials` or an update's `PATCH /credentials/{name}` failed on the wire (or
+ * its answer could not be read), so nobody knows whether the credential is what was asked for.
+ *
+ * ⛔ THIS IS WHAT STANDS IN FOR AN `HttpClientError`, WHICH CARRIES ITS REQUEST, AND THE REQUEST
+ *   BODY OF A CREATE OR UPDATE IS `{"credential_name": …, "credential_values": {"api_key": "…"}}`.
+ *   Measured 2026-09-30: on a dropped connection `JSON.stringify(error)`, `Bun.inspect(error)` and
+ *   Effect's JSON logger all printed the value, as did a failed deploy over it — the same leak
+ *   key-operations.ts's `LitellmKeyTransportError` closes. A defect reading a broken answer
+ *   (`protocol-rest.ts` reads it `Effect.orDie`) carries the same request. So `reason` keeps the
+ *   `HttpClientError` reason's TAG (a string) and nothing else: no request, no cause, no
+ *   description. The credential NAME stays — it is not secret.
+ */
+export declare class LitellmCredentialTransportError extends LitellmCredentialTransportError_base<{
+    readonly credentialName: string;
+    readonly reason: HttpClientErrorReason['_tag'] | 'Defect';
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialDebugLoggingError_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: "LitellmCredentialDebugLoggingError";
+} & Readonly<A>;
+/**
+ * The SDK prints request and response bodies to stderr while `DISTILLED_DEBUG_HTTP` is set, and a
+ * `POST /credentials` carries the values in its body — refused before any request, exactly like
+ * `key-secret.ts`'s `refuseDebugLogging` for `/key/generate`.
+ */
+export declare class LitellmCredentialDebugLoggingError extends LitellmCredentialDebugLoggingError_base<{
+    readonly credentialName: string;
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialEnvUnsetError_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: "LitellmCredentialEnvUnsetError";
+} & Readonly<A>;
+/**
+ * A write had to send the credential values and the deploying process does not hold one or more
+ * of the declared variables. The names are listed, never a value.
+ */
+export declare class LitellmCredentialEnvUnsetError extends LitellmCredentialEnvUnsetError_base<{
+    readonly credentialName: string;
+    readonly variables: readonly string[];
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialUnreadableError_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: "LitellmCredentialUnreadableError";
+} & Readonly<A>;
+/**
+ * A credentials read answered something that is not a row of the credential table (or named a
+ * different row), so adopt-by-name cannot trust it. The by-name read is this resource's only
+ * read, so a row it cannot recognise is refused rather than guessed at.
+ */
+export declare class LitellmCredentialUnreadableError extends LitellmCredentialUnreadableError_base<{
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialAbsentAfterWriteError_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: "LitellmCredentialAbsentAfterWriteError";
+} & Readonly<A>;
+/**
+ * A create or update returned no error, yet the by-name read does not answer the credential — the
+ * proxy failed to record it in memory or in the DB. Refused instead of reported as done.
+ */
+export declare class LitellmCredentialAbsentAfterWriteError extends LitellmCredentialAbsentAfterWriteError_base<{
+    readonly credentialName: string;
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialNotConvergedError_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: "LitellmCredentialNotConvergedError";
+} & Readonly<A>;
+/**
+ * The write returned no error but the credential still differs from the declaration. The update
+ * path this resource uses is a PATCH merge (credential.ts, credential-operations.ts) — or a
+ * whole-row rewrite to drop a key — so a residual difference is refused here instead of being
+ * reported as converged.
+ */
+export declare class LitellmCredentialNotConvergedError extends LitellmCredentialNotConvergedError_base<{
+    readonly credentialName: string;
+    readonly fields: readonly string[];
+}> {
+    get message(): string;
+}
+declare const LitellmCredentialRewriteError_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: "LitellmCredentialRewriteError";
+} & Readonly<A>;
+/** A rewrite deleted the old row before its POST failed. Keep only the failure tag. */
+export declare class LitellmCredentialRewriteError extends LitellmCredentialRewriteError_base<{
+    readonly credentialName: string;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+export type CredentialError = credentials.CreateCredentialCredentialsPostError | credentials.GetCredentialByNameCredentialsByNameCredentialNameGetError | credentials.UpdateCredentialCredentialsCredentialNamePatchError | credentials.DeleteCredentialCredentialsCredentialNameDeleteError | LitellmCredentialInvalidError | LitellmCredentialTransportError | LitellmCredentialRewriteError | LitellmCredentialDebugLoggingError | LitellmCredentialEnvUnsetError | LitellmCredentialUnreadableError | LitellmCredentialAbsentAfterWriteError | LitellmCredentialNotConvergedError;
+export {};
+//# sourceMappingURL=credential-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credential-errors.d.ts","sourceRoot":"","sources":["../../src/litellm/credential-errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,KAAK,WAAW,MAAM,gDAAgD,CAAC;AAEnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;;;;AAElF,yFAAyF;AACzF,qBAAa,6BAA8B,SAAQ,mCAEjD;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,+BAAgC,SAAQ,qCAEnD;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC;CAC3D,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAQ7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,kCAAmC,SAAQ,wCAEtD;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;;;;AAED;;;GAGG;AACH,qBAAa,8BAA+B,SAAQ,oCAElD;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,gCAAiC,SAAQ,sCAEpD;IACA,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;GAGG;AACH,qBAAa,sCAAuC,SAAQ,4CAE1D;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;;GAKG;AACH,qBAAa,kCAAmC,SAAQ,wCAEtD;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED,uFAAuF;AACvF,qBAAa,6BAA8B,SAAQ,mCAEjD;IACA,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAO7B;CACF;AAED,MAAM,MAAM,eAAe,GACvB,WAAW,CAAC,oCAAoC,GAChD,WAAW,CAAC,0DAA0D,GACtE,WAAW,CAAC,mDAAmD,GAC/D,WAAW,CAAC,oDAAoD,GAChE,6BAA6B,GAC7B,+BAA+B,GAC/B,6BAA6B,GAC7B,kCAAkC,GAClC,8BAA8B,GAC9B,gCAAgC,GAChC,sCAAsC,GACtC,kCAAkC,CAAC"}

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

@@ -0,0 +1,79 @@
+/**
+ * Refusals, wire bodies, the read shape and the comparison for `LiteLLM.Credential`, testable
+ * without a server. Value handling is credential-values.ts's.
+ *
+ * ⛔ WHAT IS COMPARED, WITH THE VENDOR'S MASKING IN MIND. Both reads answer `credential_values`
+ *   with SENSITIVE-keyed values masked (2 + `****` + 2, `*****` for a short string —
+ *   `litellm_logging.py::_get_masked_values`, measured in the live 1.103.0 container) and
+ *   `credential_info` in full:
+ *   - `credential_info` is the complete intended map, including on adoption. Nonempty PATCH
+ *     normally replaces DB info (`credential_endpoints/endpoints.py:314-319`, 1.103.0), while
+ *     memory merges (:385-387). Empty info leaves DB unchanged. Dropping a live info key therefore
+ *     requires a rewrite to converge both stores (`removedInfoKeys`). Every PATCH sends full info.
+ *   - the values are compared only through the seal of the values this process RESOLVED
+ *     (`valuesSeal`, credential-values.ts) — never against the masked fragments, which are
+ *     partial secrets and are never copied into state.
+ * ★ A CHANGED ROW IS PATCHED, NOT REWRITTEN. The vendor's PATCH merges VALUES by key
+ *   (`update_db_credential`:312), so updating a value or an `info` entry is a PATCH carrying the
+ *   declared `credential_info` and (only when the values are stale) the resolved
+ *   `credential_values`. A PATCH that fails on the wire leaves the row it was merging into — the
+ *   fix for the review's finding 3, where a DELETE + POST rewrite left NO row when the POST failed
+ *   after the DELETE. PATCH cannot REMOVE a value key or an in-memory info key, so dropping either
+ *   is still a whole-row rewrite (credential.ts decides). Names from the read prove removal. The
+ *   PATCH body carries `credential_name` IN THE BODY as a second member (`credential_name_body`,
+ *   wire-named `credential_name`) because the vendor's `UpdateCredentialItem` requires it and a
+ *   Smithy member has one binding — the path label can't also be the body field; the distilled
+ *   patch for it is `patches/credential_management/update_credential_credentials__credential_name__patch.json`.
+ */
+import type * as credentials from '@distilled.cloud/litellm/credential_management';
+import { type CredentialAttributes, type CredentialProps } from './credential-types.ts';
+import type { ResolvedValues } from './credential-values.ts';
+/** The first reason a declaration is refused, or `undefined`. Pure: no environment, no server. */
+export declare const firstProblem: (props: CredentialProps) => string | undefined;
+/**
+ * Wire names of the fields where the live row and the declaration disagree, for a
+ * `NotConvergedError` and for the drift decision. The NAME is identity — a changed name plans a
+ * REPLACE in credential.ts and is never compared here. Values are never compared against the
+ * live row at all: the seal decides (credential-values.ts).
+ */
+export declare const differing: (live: CredentialAttributes, props: CredentialProps) => readonly string[];
+/**
+ * One row of a credentials read, as attributes. ⛔ COPIES NO `credential_values` ENTRY: a masked
+ * fragment (`sk****45`) is a partial secret, and a sensitive key the read masks would land half a
+ * secret in Alchemy's state. The `credential_info` mirror drops SENSITIVE-KEYED entries (they are
+ * returned unmasked and would mirror a clear secret into state). The digest is the caller's
+ * (credential.ts fills `valuesSeal` from state; a row cannot supply one).
+ */
+export declare const toAttributes: (row: Record<string, unknown>) => CredentialAttributes;
+/** The rows a credentials read carries, `CredentialItem`-shaped. */
+export declare const isCredentialRow: (row: unknown) => row is Record<string, unknown>;
+/**
+ * The literal values a create or a values-stale PATCH sends, unwrapped from their `Redacted`
+ * exactly once. ⛔ EVERY DECLARED ENTRY IS SENT: the whole-row create and the values-stale PATCH
+ * both demand every declared value (`requireValues`), so there is no partial send that could
+ * leave a stale value behind under a declared key.
+ */
+export declare const literalValues: (resolved: ResolvedValues) => Readonly<Record<string, unknown>>;
+/** The body `POST /credentials` carries — the name IN THE BODY (measured with a stub fetch). */
+export declare const createBody: (props: CredentialProps, resolved: ResolvedValues) => credentials.CreateCredentialCredentialsPostRequest;
+/**
+ * The body `PATCH /credentials/{name}` carries — the declared `credential_info` always (the
+ * vendor's `UpdateCredentialItem` REQUIRES it, and the DB normally replaces the info map), the
+ * resolved `credential_values` only when the caller passes them (a values-stale write; an
+ * info-only drift sends none, so it never demands a value the environment does not hold).
+ *
+ * ⛔ `credential_name` APPEARS TWICE, ON PURPOSE: `credential_name` is the path label (its URI
+ *   placeholder is the row's address), and `credential_name_body` is the SAME value as a body
+ *   field wire-named `credential_name` — the vendor's `UpdateCredentialItem` requires the name in
+ *   the body, a Smithy member can carry only ONE binding, and the kit never renames in place (a
+ *   changed name is a REPLACE, credential.ts), so the two are always equal here.
+ */
+export declare const patchBody: (props: CredentialProps, values: Readonly<Record<string, unknown>> | undefined) => credentials.UpdateCredentialCredentialsCredentialNamePatchRequest;
+/**
+ * All live info keys absent from the intended map, including on adoption. DB replacement alone
+ * cannot clear memory, so these require a rewrite. Only names of sensitive info are remembered.
+ */
+export declare const removedInfoKeys: (prior: CredentialAttributes | undefined, props: CredentialProps) => readonly string[];
+/** Values merge in BOTH stores, so dropped names from the masked read require a rewrite. */
+export declare const removedValueKeys: (live: CredentialAttributes | undefined, props: CredentialProps) => readonly string[];
+//# sourceMappingURL=credential-form.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credential-form.d.ts","sourceRoot":"","sources":["../../src/litellm/credential-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,KAAK,WAAW,MAAM,gDAAgD,CAAC;AAEnF,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,kGAAkG;AAClG,eAAO,MAAM,YAAY,UAAW,eAAe,KAAG,MAAM,GAAG,SAoC9D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,SACd,oBAAoB,SACnB,eAAe,KACrB,SAAS,MAAM,EAUjB,CAAC;AAkBF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,oBAa3D,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,eAAe,QAAS,OAAO,KAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAGH,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,aAAa,aAAc,cAAc,KAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGtF,CAAC;AAEJ,gGAAgG;AAChG,eAAO,MAAM,UAAU,UACd,eAAe,YACZ,cAAc,KACvB,WAAW,CAAC,sCAOd,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,UACb,eAAe,UACd,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,KACpD,WAAW,CAAC,qDAQd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,UACnB,oBAAoB,GAAG,SAAS,SAChC,eAAe,KACrB,SAAS,MAAM,EAMjB,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,SACrB,oBAAoB,GAAG,SAAS,SAC/B,eAAe,KACrB,SAAS,MAAM,EACoE,CAAC"}