@homeflare/alchemy 0.43.0 → 0.45.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/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"}

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

@@ -0,0 +1,84 @@
+/**
+ * The `@distilled.cloud/litellm/credential_management` calls `LiteLLM.Credential` uses
+ * (LiteLLM 1.103.0; names verified in the generated source, never guessed):
+ *
+ *   read    `getCredentialByNameCredentialsByNameCredentialNameGet`  GET     /credentials/by_name/{name}
+ *   create  `createCredentialCredentialsPost`                        POST    /credentials
+ *   update  `updateCredentialCredentialsCredentialNamePatch`        PATCH   /credentials/{name}
+ *   delete  `deleteCredentialCredentialsCredentialNameDelete`        DELETE  /credentials/{name}
+ *
+ * ★ THE UPDATE IS A PATCH, NOT A REWRITE. The vendor's PATCH merges value keys; nonempty info
+ *   normally replaces the DB map but merges in memory (`endpoints.py:312-319,384-387`, 1.103.0).
+ *   The body carries `credential_name` as a second member
+ *   (`credential_name_body`, wire-named `credential_name`) because the vendor's
+ *   `UpdateCredentialItem` requires it in the body and a Smithy member has one binding — the
+ *   distilled patch `patches/credential_management/update_credential_credentials__credential_name__patch.json`.
+ *   A PATCH that fails on the wire leaves the row it was merging into, where the old DELETE + POST
+ *   rewrite left NO row when the POST failed after the DELETE (review finding 3). credential.ts
+ *   still rewrites to drop value or info keys, since PATCH cannot remove them from both stores.
+ * ⛔ NO MESSAGE SNIFFING (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 absence is that TAG, `catchTag`ed — never `instanceof`, never error text. A
+ *   404 from a front proxy, Access, or a wrong base path decodes as core's `NotFound` and stays an
+ *   error, never absence. A create on a name the DB already has answers `409` (`endpoints.py`'s
+ *   unique-violation handling), decoded as core `Conflict`, and is PROPAGATED: a row another writer
+ *   raced in is not this declaration's row. The PATCH's own 404 (message `Credential not found in
+ *   DB.`) is NOT `CredentialNotFound`: it stays core `NotFound`, an error — a row deleted between
+ *   the read and the PATCH must not silently read as absence.
+ * ⚠️ THE READ AND THE DELETE ASK DIFFERENT STORES (measured, `endpoints.py`): the by-name read
+ *   walks the proxy's IN-MEMORY `credential_list` (a row the proxy has not loaded answers 404),
+ *   while the delete consults the DATABASE (`delete_by_name`) and removes the in-memory entry
+ *   after. A row present in the DB but not loaded in memory reads as ABSENT, and a create for it
+ *   answers `409` — the resource reports that failure loudly instead of pretending to converge.
+ * ⚠️ Unlike pass-through endpoints, each credential is its own DB row: no semaphore.
+ */
+import * as credentials from '@distilled.cloud/litellm/credential_management';
+import * as Effect from 'effect/Effect';
+import type { CredentialAttributes } from './credential-types.ts';
+import { LitellmCredentialDebugLoggingError, LitellmCredentialTransportError, LitellmCredentialUnreadableError } from './credential-errors.ts';
+import { type LitellmOpContext } from './operations.ts';
+/**
+ * One credential by name, or `undefined` when the proxy does not hold it in memory. ⛔ ANY FAILURE
+ * OTHER THAN `CredentialNotFound` PROPAGATES: a 401, a 422 or a dead network says nothing about
+ * whether the row exists, and must never be read as absence.
+ */
+export declare const readCredential: (credentialName: string) => Effect.Effect<CredentialAttributes | undefined, credentials.GetCredentialByNameCredentialsByNameCredentialNameGetError | LitellmCredentialUnreadableError, LitellmOpContext>;
+/**
+ * POST /credentials. The answer carries no row (`{"success": true, ...}`), so the read back is the
+ * proof.
+ *
+ * ⛔ THE REQUEST BODY CARRIES THE VALUES, AND A FAILED CALL CAN CARRY ITS REQUEST — exactly the
+ *   `{"key":"sk-…"}` leak `generateKey` (key-operations.ts) closes, and it is closed the same way:
+ *   a transport failure is an `HttpClientError` in the error channel, a body that fails mid-read is
+ *   the SAME error as a DEFECT (`Effect.orDie` in core's `protocol-rest.ts`). Both become
+ *   `LitellmCredentialTransportError`, which keeps the NAME and the reason's tag and nothing else.
+ * ⛔ RECONCILE REFUSES WHILE `DISTILLED_DEBUG_HTTP` IS SET, before any request: the SDK prints
+ *   the first 400 characters of every request body (core `protocol-http.ts`), which would put the values on
+ *   stderr — the same refusal `key-secret.ts` makes for `/key/generate`.
+ */
+export declare const createCredential: (body: credentials.CreateCredentialCredentialsPostRequest) => Effect.Effect<void, credentials.CreateCredentialCredentialsPostError | LitellmCredentialTransportError, LitellmOpContext>;
+/**
+ * PATCH /credentials/{name}. Sends the full intended `credential_info` (DB replacement, memory
+ * merge) and merges resolved `credential_values` when present. The answer carries no row
+ * (`{"success": true, ...}`), so the read back is the proof.
+ *
+ * ⛔ THE SAME TWO GUARDS AS `createCredential`: the body carries the values, so a transport failure
+ *   becomes a `LitellmCredentialTransportError` that keeps the NAME and the reason's tag and
+ *   nothing else, and reconcile refuses while `DISTILLED_DEBUG_HTTP` is set (the SDK would print
+ *   the values). A PATCH that fails on the wire leaves the row in place — the point of using it
+ *   over a DELETE + POST rewrite.
+ */
+export declare const updateCredential: (body: credentials.UpdateCredentialCredentialsCredentialNamePatchRequest) => Effect.Effect<void, credentials.UpdateCredentialCredentialsCredentialNamePatchError | LitellmCredentialTransportError, LitellmOpContext>;
+/**
+ * DELETE /credentials/{name}, idempotent BY THIS FUNCTION: the vendor answers 404 for a name its
+ * database does not have, which this treats as already-absent — the DB is the authoritative store
+ * the delete consults (the read consults memory, see the header). Any other failure propagates.
+ */
+export declare const deleteCredential: (credentialName: string) => Effect.Effect<void, credentials.DeleteCredentialCredentialsCredentialNameDeleteError, LitellmOpContext>;
+/**
+ * Whether `DISTILLED_DEBUG_HTTP` is set, refused once at the top of reconcile, before even a
+ * DELETE can run (the following POST would carry values). Reads `process.env` because that is
+ * what the SDK's `protocol-http.ts` reads.
+ */
+export declare const refuseDebugLogging: (credentialName: string) => Effect.Effect<void, LitellmCredentialDebugLoggingError>;
+//# sourceMappingURL=credential-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credential-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/credential-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,WAAW,MAAM,gDAAgD,CAAC;AAC9E,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACL,kCAAkC,EAClC,+BAA+B,EAC/B,gCAAgC,EACjC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,cAAc,mBACT,MAAM,KACrB,MAAM,CAAC,MAAM,CACd,oBAAoB,GAAG,SAAS,EAC9B,WAAW,CAAC,0DAA0D,GACtE,gCAAgC,EAClC,gBAAgB,CA4Bf,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,SACrB,WAAW,CAAC,sCAAsC,KACvD,MAAM,CAAC,MAAM,CACd,IAAI,EACJ,WAAW,CAAC,oCAAoC,GAAG,+BAA+B,EAClF,gBAAgB,CAuBjB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,SACrB,WAAW,CAAC,qDAAqD,KACtE,MAAM,CAAC,MAAM,CACd,IAAI,EACJ,WAAW,CAAC,mDAAmD,GAAG,+BAA+B,EACjG,gBAAgB,CAuBjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,mBACX,MAAM,KACrB,MAAM,CAAC,MAAM,CACd,IAAI,EACJ,WAAW,CAAC,oDAAoD,EAChE,gBAAgB,CASf,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,mBACb,MAAM,KACrB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kCAAkC,CAGxC,CAAC"}

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

@@ -0,0 +1,6 @@
+import type * as credentials from '@distilled.cloud/litellm/credential_management';
+import * as Effect from 'effect/Effect';
+import { LitellmCredentialRewriteError } from './credential-errors.ts';
+import type { LitellmOpContext } from './operations.ts';
+export declare const rewriteCredential: (body: credentials.CreateCredentialCredentialsPostRequest) => Effect.Effect<void, LitellmCredentialRewriteError | credentials.DeleteCredentialCredentialsCredentialNameDeleteError, LitellmOpContext>;
+//# sourceMappingURL=credential-rewrite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credential-rewrite.d.ts","sourceRoot":"","sources":["../../src/litellm/credential-rewrite.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,WAAW,MAAM,gDAAgD,CAAC;AACnF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EACL,6BAA6B,EAE9B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,eAAO,MAAM,iBAAiB,SAAU,WAAW,CAAC,sCAAsC,4IAsCtF,CAAC"}

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

@@ -0,0 +1,87 @@
+/**
+ * What `LiteLLM.Credential` declares (props) and what is remembered about it (attributes).
+ *
+ * ⛔ NO CREDENTIAL VALUE IS EVER A PROP OR AN ATTRIBUTE (S25). Alchemy persists props AND
+ *   attributes unencrypted (`StateEncoding.ts` writes a `Redacted` value's inner string beside
+ *   the tag — `secrets/write-only.ts`, measured on alchemy 2.0.0-beta.79), and LiteLLM stores a
+ *   credential's values ENCRYPTED in its database while the reads answer them MASKED, so a value
+ *   the declaration holds is `{ fromEnv: 'NAME' }` — NAME lands in state, and the value is read
+ *   from the DEPLOYING process's environment only when a write is being made
+ *   (`credential-values.ts`, the same shape `McpServerProps.authValue` uses). Unlike a model
+ *   deployment's `os.environ/NAME` reference (the PROXY resolves that in its own environment),
+ *   the credential table stores LITERAL values — measured in the live 1.103.0 container
+ *   (`credential_endpoints/endpoints.py`: `create_credential` encrypts the body's
+ *   `credential_values` before the insert, `CredentialsRepository.create`) — so the proxy could
+ *   not resolve a reference here even if one were sent.
+ * ⛔ THE LIVE ROW'S MASKED VALUES ARE NEVER MIRRORED INTO ATTRIBUTES. Both reads answer
+ *   `credential_values` with every SENSITIVE-keyed value masked (the vendor's own rule,
+ *   `_get_masked_values` in `litellm_logging.py`: a key matching `authorization`, `token`, `key`,
+ *   `secret`, `vertex_credentials`, `credentials`, `password` or `passwd` — substring,
+ *   case-insensitive — answers `v[:2] + "****" + v[-2:]` for a string longer than four
+ *   characters, `*****` otherwise; non-string values and non-sensitive keys answer in full).
+ *   A masked fragment (`sk****45`) is a PARTIAL SECRET, so `toAttributes` copies no
+ *   `credential_values` entry at all (`credential-form.ts`); what was last written is remembered
+ *   as the digest of the values this process RESOLVED, `valuesSeal` — never the values.
+ * ⚠️ `credential_info` IS THE COMPLETE INTENDED MAP, INCLUDING ON ADOPTION. Measured in
+ *   LiteLLM 1.103.0 `credential_endpoints/endpoints.py:314-319`: a nonempty PATCH normally resets
+ *   the DB info map (except when it contains a literal `credential_info` key); an empty patch
+ *   leaves it alone. Memory only merges (:385-387), retaining removed keys until restart.
+ *   Therefore removing any live info key requires a rewrite; every PATCH sends the full map.
+ *   Sensitive info keys are refused at plan time because the vendor returns info UNMASKED.
+ *   Reads retain their NAMES only, so removal can converge without persisting their values.
+ */
+import type { FromEnv } from '../secrets/write-only.ts';
+/**
+ * The credential's name — its identity in the vendor's table (a unique column, enforced by the
+ * database, `schema.prisma`'s `Credentials` model). ADOPTED: the live row whose `credential_name`
+ * equals it. ⛔ A RENAMED ROW IS A DIFFERENT CREDENTIAL: the name is the only address the vendor's
+ * routes have, so a changed `credentialName` plans a REPLACE — the old row survives under the
+ * resource's default `retain` policy, never renamed in place.
+ */
+export interface CredentialProps {
+    readonly credentialName: string;
+    /**
+     * Free-form metadata stored beside the values (`credential_info` in the vendor's row), compared
+     * as the complete intended map with canonical-JSON deep equality (omitted means empty). ⛔ Refused for a key matching the vendor's
+     * own sensitive-key list: those belong in `credentialValues`, where LiteLLM stores them
+     * encrypted and answers them masked — in `credential_info` they would be stored in clear.
+     */
+    readonly credentialInfo?: Readonly<Record<string, unknown>>;
+    /**
+     * The credential's values, each declared as `{ fromEnv: 'NAME' }` naming the environment
+     * variable the DEPLOYING process reads at call time. AT LEAST ONE is required: LiteLLM's create
+     * model refuses a body whose `credential_values` and `model_id` are both empty
+     * (`models/credentials.py`'s `CreateCredentialItem` validator → 422), and `model_id` — which
+     * would copy a deployment's values — is not modelled here, so a value-less declaration has
+     * nothing to write. A value that never resolves in a plan-only environment never drifts
+     * (credential-values.ts); one that resolves is SENT as the literal the proxy stores encrypted.
+     */
+    readonly credentialValues: Readonly<Record<string, FromEnv>>;
+}
+export interface CredentialAttributes {
+    readonly credentialName: string;
+    /**
+     * The row's `credential_info` as the read answers it, minus any SENSITIVE-KEYED entry — those
+     * would mirror a clear secret into Alchemy's state and are skipped (`toAttributes`). The digest
+     * comparison removes undeclared live keys, including on adoption (credential-form.ts).
+     */
+    readonly credentialInfo: Readonly<Record<string, unknown>>;
+    /**
+     * `scrypt:<salt>:<digest>` of the values the LAST WRITE resolved — the only way a plan notices
+     * a rotated credential, because the live row answers masked fragments that can never be
+     * compared (`secrets/write-only.ts`). An ADOPTED row starts `''`, which reads as `stale`.
+     */
+    readonly valuesSeal: string;
+    /** Names only, never masked fragments. Optional for states written by older providers. */
+    readonly valueKeys?: readonly string[];
+    /** All info key names, including withheld sensitive entries; optional for older states. */
+    readonly infoKeys?: readonly string[];
+}
+/**
+ * Whether a value is not a string with something in it. Takes `unknown`: a declaration can say
+ * anything. (Same rule as model-types.ts and registry-support.ts.)
+ */
+export declare const isBlank: (value: unknown) => boolean;
+/** Whether a key is one the vendor itself treats as sensitive. */
+export declare const isSensitiveKey: (key: string) => boolean;
+//# sourceMappingURL=credential-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credential-types.d.ts","sourceRoot":"","sources":["../../src/litellm/credential-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAE5D;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAE3D;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,0FAA0F;IAC1F,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEvC,2FAA2F;IAC3F,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;GAGG;AACH,eAAO,MAAM,OAAO,UAAW,OAAO,KAAG,OACS,CAAC;AAmBnD,kEAAkE;AAClE,eAAO,MAAM,cAAc,QAAS,MAAM,KAAG,OAG5C,CAAC"}