@homeflare/alchemy 0.43.0 → 0.45.0

package/dist/litellm/mcp-server-credential.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The credential of a `LiteLLM.MCPServer`: resolved from the deploying process's environment,
+ * held as `Redacted`, sealed, and compared by seal.
+ *
+ * ★ `Redacted` IS THE IN-MEMORY WRAPPER, NOT THE STORAGE FORMAT. Inside this process the value is a
+ *   `Redacted<string>`, so a stray `console.log`, `JSON.stringify` or error dump prints
+ *   `<redacted>`. It is unwrapped in exactly one place: the wire body (`mcp-server-form.ts`). It is
+ *   never a prop or an attribute — see mcp-server-types.ts for why `Redacted` cannot be either.
+ * ⚠️ LITELLM DOES NOT HAND A CREDENTIAL BACK TO COMPARE WITH (UNMEASURED at 1.103.0; the resource
+ *   never relies on it). So what was last written is remembered as a SEAL, and a plan asks "is the
+ *   value in my environment the one I wrote". Four answers:
+ *   - `none`    — no credential is declared, nothing to compare.
+ *   - `unknown` — the variable is unset here, so a plan cannot tell. Never drift: a plan-only
+ *                 environment must not report every credentialed server as changed. (A write that
+ *                 CHANGES `auth_type` is the exception: it demands the value, `requireCredential`.)
+ *   - `stale`   — the variable is set and there is no seal (an adopted row, or one written outside
+ *                 this stack) or the seal disagrees. The declaration is authoritative, so it is written.
+ *   - `match`   — the seal was made from this value.
+ * ⚠️ A SEAL OF A GUESSABLE SECRET IS STILL GUESSABLE (secrets/write-only.ts). Use a random token.
+ */
+import * as Effect from 'effect/Effect';
+import * as Redacted from 'effect/Redacted';
+import { type Environment } from '../secrets/write-only.ts';
+import { LitellmMcpServerCredentialEnvUnsetError } from './mcp-server-errors.ts';
+import { type McpServerProps } from './mcp-server-types.ts';
+/** What the environment holds for the declared credential. `value` is undefined when unset or empty. */
+export interface ResolvedCredential {
+    /** The variable's NAME, for a message. `undefined` when no credential is declared. */
+    readonly variable: string | undefined;
+    readonly value: Redacted.Redacted<string> | undefined;
+}
+export type CredentialState = 'none' | 'unknown' | 'stale' | 'match';
+/** ⛔ Reads the environment at CALL time, never at module load (docs/credentials.md). */
+export declare const resolveCredential: (props: McpServerProps, env?: Environment) => ResolvedCredential;
+/** `scrypt:<salt>:<digest>` of a credential, for `credentialSeal`. ⛔ Never the value. */
+export declare const sealCredential: (value: Redacted.Redacted<string>) => string;
+export declare const credentialState: (props: McpServerProps, sealed: string, resolved?: ResolvedCredential) => CredentialState;
+/**
+ * Fails naming the variable when this write has to send a static credential and the deploying
+ * process does not hold it. Passes for a type that carries none.
+ *
+ * ⛔ A WRITE THAT CHANGES `auth_type` MUST SEND THE CREDENTIAL, exactly like a create. Measured on
+ *   the live 1.103.0 container (`mcp_server/db.py` lines 1013-1014, `_credential_auth_class`): an
+ *   edit whose auth class differs from the stored one and that sends no `credentials` key WIPES the
+ *   stored credential, and each static type is its own class. Sent without the credential, the row
+ *   would end with none while the seal still matched the old value, so a later deploy with the
+ *   variable set would be a no-op and the server would stay unauthenticated until the secret rotated.
+ */
+export declare const requireCredential: (props: McpServerProps, credential: ResolvedCredential) => Effect.Effect<void, never, never> | Effect.Effect<never, LitellmMcpServerCredentialEnvUnsetError, never>;
+//# sourceMappingURL=mcp-server-credential.d.ts.map

package/dist/litellm/mcp-server-credential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-credential.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-credential.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,KAAK,WAAW,EAAiC,MAAM,0BAA0B,CAAC;AAC3F,OAAO,EAAE,uCAAuC,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,uBAAuB,CAAC;AAE9E,wGAAwG;AACxG,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;CACvD;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAErE,wFAAwF;AACxF,eAAO,MAAM,iBAAiB,UACrB,cAAc,QAChB,WAAW,KACf,kBAQF,CAAC;AAIF,yFAAyF;AACzF,eAAO,MAAM,cAAc,UAAW,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAG,MAA+B,CAAC;AAElG,eAAO,MAAM,eAAe,UACnB,cAAc,UACb,MAAM,aACJ,kBAAkB,KAC3B,eAKF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,UAAW,cAAc,cAAc,kBAAkB,6GAQtE,CAAC"}

package/dist/litellm/mcp-server-errors.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The typed refusals `LiteLLM.MCPServer` raises on top of `@distilled.cloud/litellm`'s own SDK errors.
+ *
+ * ⛔ NO MESSAGE HERE MAY CARRY A CREDENTIAL. The only things named are the server's name, ids the
+ *   proxy already lists, field names, and the NAME of an environment variable — never a value, and
+ *   never a URL (a URL can hold a token; `mcp-server-form.ts` refuses those and redacts the read).
+ */
+import type * as mcp from '@distilled.cloud/litellm/mcp_management';
+declare const LitellmMcpServerInvalidError_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: "LitellmMcpServerInvalidError";
+} & Readonly<A>;
+/** A declaration the resource refuses before any request: a combination nobody meant. */
+export declare class LitellmMcpServerInvalidError extends LitellmMcpServerInvalidError_base<{
+    readonly serverName: string;
+    readonly problem: string;
+}> {
+    get message(): string;
+}
+declare const LitellmMcpServerCredentialEnvUnsetError_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: "LitellmMcpServerCredentialEnvUnsetError";
+} & Readonly<A>;
+/**
+ * A write must send the credential and the deploying process does not have it. An empty variable
+ * counts as unset (secrets/write-only.ts: a failed renderer writes `NAME=`, and sending `''` would
+ * store an empty credential and report a successful deploy).
+ */
+export declare class LitellmMcpServerCredentialEnvUnsetError extends LitellmMcpServerCredentialEnvUnsetError_base<{
+    readonly serverName: string;
+    readonly variable: string;
+}> {
+    get message(): string;
+}
+declare const LitellmMcpServerAmbiguousNameError_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: "LitellmMcpServerAmbiguousNameError";
+} & Readonly<A>;
+/**
+ * More than one live row carries the declared `server_name`, so adopt-by-name cannot say which one
+ * is meant. LiteLLM does not make the name unique (unmeasured on 1.103.0). Declare `serverId` to
+ * pick one — nothing is adopted, updated or deleted on a guess.
+ */
+export declare class LitellmMcpServerAmbiguousNameError extends LitellmMcpServerAmbiguousNameError_base<{
+    readonly serverName: string;
+    readonly serverIds: readonly string[];
+}> {
+    get message(): string;
+}
+declare const LitellmMcpServerUnreadableError_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: "LitellmMcpServerUnreadableError";
+} & Readonly<A>;
+/** `GET /v1/mcp/server` answered something that is not a list of servers. */
+export declare class LitellmMcpServerUnreadableError extends LitellmMcpServerUnreadableError_base<{
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+declare const LitellmMcpServerAbsentAfterWriteError_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: "LitellmMcpServerAbsentAfterWriteError";
+} & Readonly<A>;
+/**
+ * A create or edit returned no error, yet the row is absent on the read back: neither in the list
+ * NOR in a database-backed read by id (the list alone is the registry, which can lag a commit).
+ */
+export declare class LitellmMcpServerAbsentAfterWriteError extends LitellmMcpServerAbsentAfterWriteError_base<{
+    readonly serverName: string;
+    readonly serverId: string;
+}> {
+    get message(): string;
+}
+declare const LitellmMcpServerNotConvergedError_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: "LitellmMcpServerNotConvergedError";
+} & Readonly<A>;
+/**
+ * The write returned no error but the row still differs from the declaration. The edit route may
+ * merge with `exclude_none` or a truthiness check (an empty list or a `false` never lands); the
+ * read back says so instead of reporting a converged row. Unmeasured on 1.103.0.
+ */
+export declare class LitellmMcpServerNotConvergedError extends LitellmMcpServerNotConvergedError_base<{
+    readonly serverName: string;
+    readonly serverId: string;
+    readonly fields: readonly string[];
+}> {
+    get message(): string;
+}
+declare const LitellmMcpServerDescriptionShadowedError_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: "LitellmMcpServerDescriptionShadowedError";
+} & Readonly<A>;
+/**
+ * The declared `description` cannot be applied: the live row's `mcp_info` has a `description` key
+ * (even a null one), and LiteLLM answers that in preference to the column, which is all this
+ * resource writes (`mcp_info` is not modelled). Raised BEFORE any write, so the row is untouched.
+ * Nothing here names the text itself: a description is free text a person wrote.
+ */
+export declare class LitellmMcpServerDescriptionShadowedError extends LitellmMcpServerDescriptionShadowedError_base<{
+    readonly serverName: string;
+    readonly serverId: string;
+}> {
+    get message(): string;
+}
+export type McpServerError = mcp.AddMcpServerV1McpServerPostError | mcp.EditMcpServerV1McpServerPutError | mcp.FetchAllMcpServersV1McpServerGetError | mcp.FetchMcpServerV1McpServerServerIdGetError | mcp.RemoveMcpServerV1McpServerServerIdDeleteError | LitellmMcpServerInvalidError | LitellmMcpServerCredentialEnvUnsetError | LitellmMcpServerAmbiguousNameError | LitellmMcpServerUnreadableError | LitellmMcpServerAbsentAfterWriteError | LitellmMcpServerNotConvergedError | LitellmMcpServerDescriptionShadowedError;
+export {};
+//# sourceMappingURL=mcp-server-errors.d.ts.map

package/dist/litellm/mcp-server-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-errors.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,yCAAyC,CAAC;;;;AAGpE,yFAAyF;AACzF,qBAAa,4BAA6B,SAAQ,kCAAiD;IACjG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,uCAAwC,SAAQ,6CAE3D;IACA,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,kCAAmC,SAAQ,wCAEtD;IACA,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED,6EAA6E;AAC7E,qBAAa,+BAAgC,SAAQ,qCAEnD;IACA,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;GAGG;AACH,qBAAa,qCAAsC,SAAQ,2CAEzD;IACA,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,iCAAkC,SAAQ,uCAErD;IACA,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAK7B;CACF;;;;AAED;;;;;GAKG;AACH,qBAAa,wCAAyC,SAAQ,8CAE5D;IACA,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;AAED,MAAM,MAAM,cAAc,GACtB,GAAG,CAAC,gCAAgC,GACpC,GAAG,CAAC,gCAAgC,GACpC,GAAG,CAAC,qCAAqC,GACzC,GAAG,CAAC,yCAAyC,GAC7C,GAAG,CAAC,6CAA6C,GACjD,4BAA4B,GAC5B,uCAAuC,GACvC,kCAAkC,GAClC,+BAA+B,GAC/B,qCAAqC,GACrC,iCAAiC,GACjC,wCAAwC,CAAC"}

package/dist/litellm/mcp-server-form.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Refusals, wire bodies, the read shape and the comparison for `LiteLLM.MCPServer`, testable
+ * without a server. The URL rules are in `mcp-server-url.ts`.
+ *
+ * ⛔ TWO ACCESS GRANTS ARE ALWAYS COMPARED, WITH A CLOSED DEFAULT. `allow_all_keys` (default
+ *   false) and `mcp_access_groups` (default empty) decide which keys can reach a server, so a live
+ *   value that differs from the declaration is corrected rather than left as it is.
+ * ⛔ `allowed_tools` IS NOT ONE OF THEM: it is compared and sent ONLY WHEN DECLARED, like `alias`.
+ *   An empty list is the OPEN state, not a closed one. Measured on the live 1.103.0 container:
+ *   `server_applies_tool_allowlist` (`mcp_server/utils.py`) is "the `mcp_info` enforce flag, or a
+ *   non-empty `allowed_tools`", and `filter_tools_by_allowed_tools` (`server.py` lines 1692-1698)
+ *   returns every tool when it is false. This resource does not model `mcp_info`, so a default of
+ *   `[]` would switch a live whitelist OFF the moment a row is adopted without restating it, and an
+ *   adopted row is planned `adopted` (Alchemy's adoption branch), so no `update` would show. An
+ *   undeclared list is left exactly as the proxy holds it.
+ * ★ Descriptive fields (`alias`, `description`) are also compared only when declared, so adopting a
+ *   row never clears text a person wrote. That holds on the wire too, for `alias` only because an
+ *   update RE-SENDS the live alias whenever it sends a `serverName` (`identityOnUpdate` below).
+ * ⚠️ EVERY UPDATE SENDS THE FULL MANAGED SET, NOT ONLY THE FIELDS THAT DIFFER, bar the two name
+ *   fields, which `identityOnUpdate` sends selectively because LiteLLM defaults an alias. The edit
+ *   route is a PARTIAL update at 1.103.0 (measured by reading the live container's
+ *   `mcp_server/db.py`, the update function's `exclude_unset=True`: fields the caller did not send
+ *   keep their stored value; no live call was made), so a field this resource does not send is left
+ *   alone. Sending the whole managed set is still correct, and reconcile reads back and fails loudly
+ *   if a declared field did not land (`LitellmMcpServerNotConvergedError`). Whether a `false` or an
+ *   empty list is written rather than skipped stays UNMEASURED, which is what the read back guards.
+ */
+import type * as mcp from '@distilled.cloud/litellm/mcp_management';
+import * as Redacted from 'effect/Redacted';
+import { type McpServerAttributes, type McpServerProps } from './mcp-server-types.ts';
+/** The first reason a declaration is refused, or `undefined`. Pure: no environment, no server. */
+export declare const firstProblem: (props: McpServerProps) => string | undefined;
+/**
+ * One row of `GET /v1/mcp/server`, or of the by-id read, as attributes.
+ *
+ * ⚠️ THE LIST'S `description` IS `mcp_info.description` WHEN THAT EXISTS, else the column (measured
+ *   on the live 1.103.0 container: `_build_mcp_server_table` and, on registration,
+ *   `build_mcp_server_from_table`, which copies the column into `mcp_info` only when `mcp_info`
+ *   has none). This resource writes only the column, so a declared description cannot be read back
+ *   from a row whose `mcp_info` holds another: reconcile refuses that before it writes.
+ *
+ * ⛔ `credentials`, `static_headers`, `env`, `env_vars` and every other field are deliberately NOT
+ *   copied: what LiteLLM stores as a credential stays on the proxy. The `credentialSeal` is filled
+ *   in by the caller from the previous state; a row cannot supply one.
+ */
+export declare const toAttributes: (row: mcp.LiteLLMMCPServerTable) => McpServerAttributes;
+/** Wire names of the fields where the live row and the declaration disagree. */
+export declare const differing: (live: McpServerAttributes, props: McpServerProps) => readonly string[];
+export declare const createBody: (props: McpServerProps, serverId: string, credential: Redacted.Redacted<string> | undefined) => mcp.AddMcpServerV1McpServerPostRequest;
+/**
+ * `clearCredentials` sends an explicit `credentials: null`, for a server moving off a static auth
+ * type. Whether LiteLLM clears its stored credential on `null` or ignores it (an `exclude_none`
+ * merge) is UNMEASURED at 1.103.0; either way nothing is sent that could set a wrong one.
+ */
+export declare const updateBody: (props: McpServerProps, serverId: string, credential: Redacted.Redacted<string> | undefined, clearCredentials: boolean, live: McpServerAttributes) => mcp.EditMcpServerV1McpServerPutRequest;
+//# sourceMappingURL=mcp-server-form.d.ts.map

package/dist/litellm/mcp-server-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-form.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAIpB,MAAM,uBAAuB,CAAC;AA+B/B,kGAAkG;AAClG,eAAO,MAAM,YAAY,UAAW,cAAc,KAAG,MAAM,GAAG,SAsC7D,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,QAAS,GAAG,CAAC,qBAAqB,KAAG,mBAY5D,CAAC;AAKH,gFAAgF;AAChF,eAAO,MAAM,SAAS,SAAU,mBAAmB,SAAS,cAAc,KAAG,SAAS,MAAM,EAgB3F,CAAC;AAiDF,eAAO,MAAM,UAAU,UACd,cAAc,YACX,MAAM,cACJ,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,KAChD,GAAG,CAAC,kCAKL,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,UACd,cAAc,YACX,MAAM,cACJ,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,oBAC/B,OAAO,QACnB,mBAAmB,KACxB,GAAG,CAAC,kCAKL,CAAC"}

package/dist/litellm/mcp-server-locate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Which live row a `LiteLLM.MCPServer` declaration means, and which id a new row would ask for.
+ *
+ * ⛔ THE LIST DECIDES FIRST, THE DATABASE SECOND. `GET /v1/mcp/server` is LiteLLM's in-memory
+ *   registry, not the table (mcp-server-operations.ts says how a committed row can be missing from
+ *   it). A row the list does not show is therefore looked for BY ID in the database, with the id
+ *   this declaration would use. Without that second read, a row created a moment ago whose
+ *   registry refresh failed would be POSTed again: the id is deterministic, LiteLLM answers 400
+ *   "already exists", and the resource would be wedged on a row it can neither see nor adopt.
+ * ⚠️ ADOPT-BY-NAME NEEDS THE LIST: a name cannot be read from the table by this route family. A row
+ *   the registry lacks is adoptable only by declaring its `serverId`.
+ */
+import type * as mcp from '@distilled.cloud/litellm/mcp_management';
+import * as Effect from 'effect/Effect';
+import { LitellmMcpServerAmbiguousNameError } from './mcp-server-errors.ts';
+import type { McpServerAttributes, McpServerProps } from './mcp-server-types.ts';
+/**
+ * The live row among the LISTED ones, or `undefined`. A pinned id (from state, else declared) wins;
+ * otherwise the name decides, and an ambiguous name is refused.
+ */
+export declare const locate: (rows: readonly mcp.LiteLLMMCPServerTable[], props: McpServerProps, output: McpServerAttributes | undefined) => Effect.Effect<never, LitellmMcpServerAmbiguousNameError, never> | Effect.Effect<mcp.LiteLLMMCPServerTable | undefined, never, never>;
+/** The id a create asks for: the recorded one, else the declared one, else a deterministic name. */
+export declare const wantedId: (id: string, instanceId: string, props: McpServerProps, output: McpServerAttributes | undefined) => Effect.Effect<string, never, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage>;
+/** The live row this declaration means, from the list, else from the table by the id it would use. */
+export declare const findLive: (id: string, instanceId: string, props: McpServerProps, output: McpServerAttributes | undefined) => Effect.Effect<mcp.LiteLLMMCPServerTable | undefined, 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 | LitellmMcpServerAmbiguousNameError | import("./mcp-server-errors.ts").LitellmMcpServerUnreadableError | 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 | mcp.UnprocessableEntity, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | mcp.LitellmOpContext>;
+//# sourceMappingURL=mcp-server-locate.d.ts.map

package/dist/litellm/mcp-server-locate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-locate.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-locate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,yCAAyC,CAAC;AAEpE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,kCAAkC,EAAE,MAAM,wBAAwB,CAAC;AAE5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEjF;;;GAGG;AACH,eAAO,MAAM,MAAM,SACX,SAAS,GAAG,CAAC,qBAAqB,EAAE,SACnC,cAAc,UACb,mBAAmB,GAAG,SAAS,yIAaxC,CAAC;AAEF,oGAAoG;AACpG,eAAO,MAAM,QAAQ,OACf,MAAM,cACE,MAAM,SACX,cAAc,UACb,mBAAmB,GAAG,SAAS,mHAMqC,CAAC;AAE/E,sGAAsG;AACtG,eAAO,MAAM,QAAQ,OACf,MAAM,cACE,MAAM,SACX,cAAc,UACb,mBAAmB,GAAG,SAAS,i0BAMrC,CAAC"}

package/dist/litellm/mcp-server-operations.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The five LiteLLM `/v1/mcp/server*` calls `LiteLLM.MCPServer` uses, through the SDK's typed
+ * operations in `@distilled.cloud/litellm/mcp_management` (LiteLLM 1.103.0):
+ *
+ *   list    `fetchAllMcpServersV1McpServerGet`          GET    /v1/mcp/server
+ *   read    `fetchMcpServerV1McpServerServerIdGet`      GET    /v1/mcp/server/{server_id}
+ *   create  `addMcpServerV1McpServerPost`               POST   /v1/mcp/server
+ *   update  `editMcpServerV1McpServerPut`               PUT    /v1/mcp/server
+ *   delete  `removeMcpServerV1McpServerServerIdDelete`  DELETE /v1/mcp/server/{server_id}
+ *
+ * ⛔ THE LIST IS NOT THE TABLE. Measured 2026-09-29 by reading the live 1.103.0 container:
+ *   `GET /v1/mcp/server` answers `global_mcp_server_manager`'s IN-MEMORY REGISTRY
+ *   (`_resolve_accessible_mcp_servers`), not `LiteLLM_MCPServerTable`. `reload_servers_from_database`
+ *   loads only rows whose approval status is null, active or approved, and skips a row whose build
+ *   throws; the registry is narrowed again by the caller's key (`object_permission.mcp_servers`); and
+ *   `add_mcp_server` only LOGS a failed registry refresh after the row is committed. So a row that
+ *   is absent from the list can be live in the database. The list is right for adopt-by-name, and
+ *   wrong as proof of absence. The database is read by ID (`readMcpServer`): `fetch_mcp_server`
+ *   asks `get_mcp_server` (the table) first and answers 404 only when the table, the registry and
+ *   a name lookup all miss.
+ * ⚠️ THE BY-ID READ HAS SIDE EFFECTS, so it is used only where the list cannot decide: it registers
+ *   the row in the registry (`add_server`) and runs a health check against the upstream server.
+ * ⛔ NO MESSAGE SNIFFING. `mcp_management` declares only `UnprocessableEntity` beyond the shared
+ *   errors — the distilled `patches/` that type `BadRequest`/`NotFound` cover five other admin tags
+ *   (budget, key, team, internal_user, model), not this one. A 404 from these routes still decodes
+ *   at run time as the SDK's `NotFound` class (core's `HTTP_STATUS_MAP`), invisible to the type
+ *   checker; `readMcpServer` tests that class with `instanceof` and nothing else, and a REAL READ
+ *   decides (`deleteMcpServer`), the way `budget-operations.ts` and pass-through `operations.ts` do.
+ *   The typed fix is a distilled patch for this tag, which belongs in the distilled clone.
+ * ⚠️ Unlike pass-through endpoints, each server is its own DB row: no semaphore.
+ */
+import * as mcp from '@distilled.cloud/litellm/mcp_management';
+import * as Effect from 'effect/Effect';
+import { type LitellmOpContext } from './operations.ts';
+import { LitellmMcpServerUnreadableError } from './mcp-server-errors.ts';
+/** ⚠️ The REGISTRY as the caller may see it, not the table: see the file header. */
+export declare const listMcpServers: () => Effect.Effect<readonly mcp.LiteLLMMCPServerTable[], mcp.FetchAllMcpServersV1McpServerGetError | LitellmMcpServerUnreadableError, LitellmOpContext>;
+/**
+ * One row read BY ID, DATABASE FIRST, or `undefined` when the proxy has no such row.
+ *
+ * ★ THE ROW MUST CARRY THE ID ASKED FOR. When the table has no row, `fetch_mcp_server` falls back to
+ *   the registry and then to a lookup by NAME or alias, so an id that happens to be another server's
+ *   name answers THAT server. A row with another id is "no such row" here.
+ * ⛔ ANY FAILURE OTHER THAN `NotFound` PROPAGATES: a 401, a 500 or a dead network says nothing about
+ *   whether the row exists, and must never be read as absence.
+ */
+export declare const readMcpServer: (serverId: string) => Effect.Effect<mcp.LiteLLMMCPServerTable | undefined, mcp.FetchMcpServerV1McpServerServerIdGetError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+/** Answers the created row, which carries the `server_id` LiteLLM actually used. */
+export declare const createMcpServer: (body: mcp.AddMcpServerV1McpServerPostRequest) => Effect.Effect<mcp.LiteLLMMCPServerTable, mcp.AddMcpServerV1McpServerPostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const updateMcpServer: (body: mcp.EditMcpServerV1McpServerPutRequest) => Effect.Effect<void, mcp.EditMcpServerV1McpServerPutError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+/**
+ * Idempotent BY THIS FUNCTION, not by the vendor. The DELETE is ALWAYS SENT: it acts on the table
+ * (`delete_mcp_server` answers 404 for a missing row), so a row the list does not show, because the
+ * registry dropped it, is still removed. A list that skipped the call for an unlisted id would drop
+ * Alchemy's state for a row that stays live in the database.
+ *
+ * If the DELETE fails, the failure is swallowed only when a DATABASE-BACKED read by id says the row is
+ * absent (`readMcpServer`: a concurrent removal, or a row already gone). A row that is still there,
+ * or a read that cannot say, re-raises the ORIGINAL error — so a delete refused for lack of rights,
+ * which leaves the row live, is never reported as done.
+ */
+export declare const deleteMcpServer: (serverId: string) => Effect.Effect<void, mcp.RemoveMcpServerV1McpServerServerIdDeleteError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+//# sourceMappingURL=mcp-server-operations.d.ts.map

package/dist/litellm/mcp-server-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,GAAG,MAAM,yCAAyC,CAAC;AAE/D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC;AAOzE,oFAAoF;AACpF,eAAO,MAAM,cAAc,QAAO,MAAM,CAAC,MAAM,CAC7C,SAAS,GAAG,CAAC,qBAAqB,EAAE,EACpC,GAAG,CAAC,qCAAqC,GAAG,+BAA+B,EAC3E,gBAAgB,CAkBf,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,aAAc,MAAM,oKAM3C,CAAC;AAEJ,oFAAoF;AACpF,eAAO,MAAM,eAAe,SAAU,GAAG,CAAC,kCAAkC,+IACvB,CAAC;AAEtD,eAAO,MAAM,eAAe,SAAU,GAAG,CAAC,kCAAkC,0HACH,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,aAAc,MAAM,uIAS7C,CAAC"}

package/dist/litellm/mcp-server-shadow.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The one description this resource cannot write: a row whose `mcp_info` already has a
+ * `description` key.
+ *
+ * ⛔ MEASURED 2026-09-29 on the live 1.103.0 container and its database (read only): the list route
+ *   builds each row's `description` from `mcp_info.get("description")` (`_build_mcp_server_table`),
+ *   and registering a row copies the `description` COLUMN into `mcp_info` only when the KEY IS ABSENT
+ *   from `mcp_info` (`build_mcp_server_from_table`, `"description" not in mcp_info`). This resource
+ *   writes the column and models no `mcp_info`, so on a row whose `mcp_info` has the key, a declared
+ *   description lands in the column and is never read back, and every deploy would fail
+ *   `LitellmMcpServerNotConvergedError` after the write. Live: 2 of the 9 rows in
+ *   `LiteLLM_MCPServerTable` have the key: `linear` (a string, with the same length as its column)
+ *   and `Memos_CF` (a JSON null, with a NULL column). A key holding null shadows the column too.
+ * ★ THE ROW IS READ BY ID FROM THE TABLE, because the list's `mcp_info` already has the column
+ *   folded in: a description in it could be either, and only the table row tells them apart.
+ * ⚠️ Not `mcp_info` merging: a sent `mcp_info` REPLACES the stored one, and the list's copy carries
+ *   fields the proxy adds on the way out (`is_public`), which would be persisted.
+ */
+import * as Effect from 'effect/Effect';
+import { LitellmMcpServerDescriptionShadowedError } from './mcp-server-errors.ts';
+import type { McpServerProps } from './mcp-server-types.ts';
+/** Fails BEFORE any write when the declared description would be hidden by the row's `mcp_info`. */
+export declare const refuseShadowedDescription: (props: McpServerProps, serverId: string) => Effect.Effect<void, LitellmMcpServerDescriptionShadowedError | import("@distilled.cloud/litellm/mcp_management").FetchMcpServerV1McpServerServerIdGetError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+//# sourceMappingURL=mcp-server-shadow.d.ts.map

package/dist/litellm/mcp-server-shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-shadow.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-shadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,wCAAwC,EAAE,MAAM,wBAAwB,CAAC;AAElF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,oGAAoG;AACpG,eAAO,MAAM,yBAAyB,UAAW,cAAc,YAAY,MAAM,4NAoB1E,CAAC"}

package/dist/litellm/mcp-server-types.d.ts

@@ -0,0 +1,118 @@
+/**
+ * What a `LiteLLM.MCPServer` declares (props) and what is remembered about it (attributes).
+ *
+ * ⛔ NEITHER TYPE HOLDS A CREDENTIAL (S25). Alchemy persists props AND attributes in its state
+ *   store, and it does not encrypt them: `StateEncoding.ts` TAGS a `Redacted` value and writes the
+ *   inner value beside the tag (measured on alchemy 2.0.0-beta.79, `State/StateEncoding.ts` line
+ *   87-89). So a `Redacted<string>` prop would still land in state as plaintext. The credential is
+ *   declared as `{ fromEnv: 'NAME' }`; the NAME is what is stored, and the value lives only in the
+ *   deploying process (wrapped in `Redacted` there, `mcp-server-credential.ts`) and on the wire.
+ * ★ WHAT LITELLM STORES IS NEVER MIRRORED BACK. The list route carries `credentials`,
+ *   `static_headers`, `env` and `env_vars`; `toAttributes` (mcp-server-form.ts) copies none of them.
+ * ⚠️ NOT MODELLED, on purpose: `stdio` (it runs a command on the proxy host), the OAuth client
+ *   registration fields, `static_headers`/`extra_headers`, `mcp_info`, tool renames, BYOK and
+ *   the AWS / token-exchange auth types (each needs credential fields this resource does not
+ *   model). A row that uses them can still be adopted; what is not declared is left alone.
+ * ⚠️ NO `teams`. The create and edit requests of `@distilled.cloud/litellm` 0.3.0 (LiteLLM 1.103.0)
+ *   have no team field; `teams` exists only on the row a read returns. Team access is granted on
+ *   the team side (its `object_permission`), which is a different resource.
+ */
+import type { FromEnv } from '../secrets/write-only.ts';
+/** `stdio` is refused by the type: it would run a declared command on the proxy host. */
+export type McpTransport = 'sse' | 'http';
+/**
+ * Auth types that carry ONE static credential (`credentials.auth_value` on the wire). Which header
+ * each one becomes is LiteLLM's, not this package's (unmeasured here).
+ */
+export type McpStaticAuthType = 'api_key' | 'bearer_token' | 'basic' | 'authorization' | 'token';
+/** `oauth2` is a per-user flow LiteLLM runs itself: no static credential is declared for it. */
+export type McpAuthType = 'none' | 'oauth2' | McpStaticAuthType;
+export interface McpServerProps {
+    /**
+     * The server's name, and the way an existing row is ADOPTED: the live row whose `server_name`
+     * equals it. Changing it is an update of the same row, never a replace. The update re-sends the
+     * live alias, so the tool prefix stays. Declare `alias` to change the prefix.
+     */
+    readonly serverName: string;
+    /**
+     * Pins the live row (adopts by id) or chooses the id a create asks for. Without it, a live row
+     * is found by `serverName` and a new one gets a deterministic physical name. ⛔ A DIFFERENT
+     * DECLARED ID IS A REPLACE (create-first, so the old row is only removed by an opt-in
+     * `RemovalPolicy.destroy()`).
+     */
+    readonly serverId?: string;
+    /**
+     * The tool prefix LiteLLM shows (`<alias>-<tool>`). Compared only when declared, and an
+     * undeclared live alias is KEPT: an update that sends a `serverName` with no alias would make
+     * LiteLLM rewrite the alias to the name, so the live one is re-sent (mcp-server-form.ts).
+     * Declare this to change the prefix; a changed `serverName` does not. ⛔ Must match
+     * `^[A-Za-z0-9._]{1,128}$` (same rule as `serverName`): LiteLLM 1.103 runs `validate_tool_name`
+     * on it, so a space, `/`, `:`, `@` or more than 128 characters is a 400 only at apply.
+     */
+    readonly alias?: string;
+    /**
+     * The upstream MCP endpoint, `http` or `https`. ⛔ Refused if it carries userinfo, a fragment or
+     * a secret-looking query parameter (`?token=…`): the URL is a prop, so it lands in state. Declare
+     * the credential as `authValue` instead.
+     */
+    readonly url: string;
+    /** `sse` or `http`. Required: LiteLLM's own default is not this resource's to fix silently. */
+    readonly transport: McpTransport;
+    /** Required: a default would silently choose "no authentication". */
+    readonly authType: McpAuthType;
+    /**
+     * The static credential for a `McpStaticAuthType`, by the NAME of the environment variable that
+     * holds it. Required for those types and refused for the others.
+     */
+    readonly authValue?: FromEnv;
+    /**
+     * Compared only when declared. ⚠️ A blank one (`''` or whitespace) is refused: LiteLLM copies the
+     * column into `mcp_info` only when the value is truthy, so it would never converge. LiteLLM's
+     * list answers `mcp_info.description` in preference to this column, and this resource writes only
+     * the column. A row whose `mcp_info` has a `description` key (even a null one) that differs from
+     * the declaration is refused (`LitellmMcpServerDescriptionShadowedError`) rather than written and
+     * failed on the read back.
+     */
+    readonly description?: string;
+    /**
+     * Whether EVERY virtual key may call this server. Always compared, default `false`: it is an
+     * access grant, so an adopted row that has it on is corrected, never left open silently.
+     */
+    readonly allowAllKeys?: boolean;
+    /**
+     * The tools a caller may use, compared as a set. ⛔ COMPARED AND SENT ONLY WHEN DECLARED: omitted
+     * leaves the live whitelist exactly as it is. ⚠️ `[]` is NOT "closed" — at 1.103.0 an empty list
+     * turns the whitelist off (every tool is returned) unless the row's `mcp_info` carries the enforce
+     * flag, which this resource does not model. Declare `[]` only to mean "no restriction".
+     */
+    readonly allowedTools?: readonly string[];
+    /** Access groups this server belongs to. Always compared (as a set). */
+    readonly mcpAccessGroups?: readonly string[];
+}
+export interface McpServerAttributes {
+    readonly serverId: string;
+    readonly serverName: string | null;
+    readonly alias: string | null;
+    /** ⛔ REDACTED on the way in (userinfo and secret-looking query values become `REDACTED`). */
+    readonly url: string | null;
+    readonly transport: string;
+    /** `none` when the live row carries no auth type. */
+    readonly authType: string;
+    readonly description: string | null;
+    readonly allowAllKeys: boolean;
+    readonly allowedTools: readonly string[];
+    readonly mcpAccessGroups: readonly string[];
+    /**
+     * `scrypt:<salt>:<digest>` of the credential last written, or `''`. ⛔ Never the value. LiteLLM
+     * does not return a credential to compare with, so this is how a plan notices a rotated one
+     * (secrets/write-only.ts). It is carried from the previous state, never read from the row.
+     */
+    readonly credentialSeal: string;
+}
+/** Whether a value is not a string with something in it. Takes `unknown`: a declaration can say anything. */
+export declare const isBlank: (value: unknown) => boolean;
+/** Whether an auth type carries one static credential. Takes a string: a live row can say anything. */
+export declare const isStaticAuthType: (authType: string) => boolean;
+export declare const AUTH_TYPES: readonly McpAuthType[];
+export declare const TRANSPORTS: readonly McpTransport[];
+//# sourceMappingURL=mcp-server-types.d.ts.map

package/dist/litellm/mcp-server-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-types.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD,yFAAyF;AACzF,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,MAAM,CAAC;AAE1C;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,cAAc,GAAG,OAAO,GAAG,eAAe,GAAG,OAAO,CAAC;AAEjG,gGAAgG;AAChG,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,iBAAiB,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,+FAA+F;IAC/F,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,wEAAwE;IACxE,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,6FAA6F;IAC7F,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,6GAA6G;AAC7G,eAAO,MAAM,OAAO,UAAW,OAAO,KAAG,OACS,CAAC;AAUnD,uGAAuG;AACvG,eAAO,MAAM,gBAAgB,aAAc,MAAM,KAAG,OAA+B,CAAC;AAEpF,eAAO,MAAM,UAAU,EAAE,SAAS,WAAW,EAQ5C,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,SAAS,YAAY,EAAoB,CAAC"}

package/dist/litellm/mcp-server-url.d.ts

@@ -0,0 +1,11 @@
+/** Why a URL may not be declared, or `undefined`. ⛔ Never quotes the URL: it may hold the secret. */
+export declare const urlProblem: (raw: unknown) => string | undefined;
+/**
+ * `userinfo` and secret-looking query values replaced with `REDACTED`, so a live URL that carries a
+ * token never reaches Alchemy's unencrypted state.
+ * ★ A URL THAT NEEDS NO REDACTION COMES BACK BYTE-FOR-BYTE, never re-serialised: `URL#toString`
+ *   adds a trailing slash to a bare origin, and a declared `https://host` would then differ from
+ *   its own live row on every plan. A URL that does not parse is returned as it is.
+ */
+export declare const redactUrl: (raw: string) => string;
+//# sourceMappingURL=mcp-server-url.d.ts.map

package/dist/litellm/mcp-server-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-url.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server-url.ts"],"names":[],"mappings":"AAaA,qGAAqG;AACrG,eAAO,MAAM,UAAU,QAAS,OAAO,KAAG,MAAM,GAAG,SAmBlD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,QAAS,MAAM,KAAG,MAuBvC,CAAC"}

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

@@ -0,0 +1,95 @@
+/**
+ * `LiteLLM.MCPServer` — one row of LiteLLM's `LiteLLM_MCPServerTable` (`/v1/mcp/server`), an
+ * upstream MCP server the proxy's gateway exposes to keys and teams.
+ *
+ * ★ ADOPT BY NAME. `serverName` finds the live row whose `server_name` matches; declare `serverId`
+ *   to pin one instead. A live row with no state is `Unowned`, so it needs `--adopt`. Two rows with
+ *   the same name are refused, never guessed at (`LitellmMcpServerAmbiguousNameError`).
+ * ★ `defaultRemovalPolicy: 'retain'` — a server's removal takes its tools from every key, team and
+ *   seat that reaches it. Opt in with `.pipe(RemovalPolicy.destroy())`.
+ * ⛔ THE CREDENTIAL IS `{ fromEnv: 'NAME' }`, NEVER A VALUE (S25): mcp-server-types.ts says why a
+ *   `Redacted` prop would still be stored in plaintext. Reading a server never reveals auth material
+ *   either — `toAttributes` copies no credential — and a rotated credential is noticed through a
+ *   seal (mcp-server-credential.ts).
+ * ⛔ NO LITELLM CREDENTIAL IS A PROP either: `litellmProviders`' layer supplies `Credentials`.
+ * ⛔ THE LIST IS LITELLM'S IN-MEMORY REGISTRY, NOT THE TABLE (mcp-server-operations.ts): a committed row
+ *   can be missing from it. So a row the list lacks is read by id from the table (`findLive`), the read
+ *   back after a write falls back to the same read, and a delete always sends its DELETE.
+ * ⛔ AN UPDATE NEVER LETS LITELLM DEFAULT THE ALIAS (mcp-server-form.ts): the alias is the tool prefix.
+ * ⚠️ A `description` that the row's `mcp_info` would hide is refused before any write (mcp-server-shadow.ts).
+ * ⚠️ UNMEASURED AT 1.103.0, each guarded by a read back: whether a create honours a supplied
+ *   `server_id`, and whether an empty list or a `false` lands on an edit (that the edit is a partial
+ *   update is read from the source, `mcp-server-form.ts`). Nothing here assumes them; the returned
+ *   row is what is recorded.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import { LitellmMcpServerAbsentAfterWriteError, LitellmMcpServerInvalidError, LitellmMcpServerNotConvergedError } from './mcp-server-errors.ts';
+import { type McpServerAttributes, type McpServerProps } from './mcp-server-types.ts';
+export type { McpServerAttributes, McpServerProps };
+export type { McpServerError } from './mcp-server-errors.ts';
+export interface LiteLLMMCPServer extends Resource<'LiteLLM.MCPServer', McpServerProps, McpServerAttributes> {
+}
+export declare const LiteLLMMCPServer: import("alchemy").ResourceClass<LiteLLMMCPServer>;
+export declare const isLiteLLMMCPServer: (value: unknown) => value is LiteLLMMCPServer;
+type Args<P> = {
+    id: string;
+    instanceId: string;
+    output: McpServerAttributes | undefined;
+} & P;
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export declare const mcpServerHandlers: {
+    /**
+     * ⛔ WITH NO `output` THIS IS ALCHEMY'S ADOPTION PROBE, AND THE ONLY PLAN-TIME HOOK A NEW SERVER
+     *   GETS — so the refusals run here too. Measured on beta.79 (`Plan.ts` lines 1303-1316, the
+     *   `oldState === undefined` branch): a declaration with no state row is `read` with `olds: news`
+     *   and never `diff`ed, and Apply then commits its props as `creating` BEFORE `reconcile` runs. A
+     *   URL that carries a token would already be in the unencrypted store when reconcile refused it.
+     * ★ A DEFECT (`Effect.die`), NOT A TYPED FAILURE, and that is what keeps it from wedging a stage:
+     *   the same call shape is Alchemy's recovery read of an interrupted create (`Plan.ts` lines
+     *   1428-1447), with the STORED props, and only a defect is caught there (`Effect.catchDefect`
+     *   degrades it to "nothing recovered"). A typed failure would block the plan on props that a
+     *   later, stricter release now refuses. The cold-start probe has no such catch, so there the
+     *   defect fails the plan, as intended. `pbs-notification-target-lifecycle.ts` reasons the same.
+     */
+    read: ({ id, instanceId, olds, output }: Args<{
+        olds: McpServerProps;
+    }>) => Effect.Effect<McpServerAttributes | undefined, 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("./mcp-server-errors.ts").LitellmMcpServerAmbiguousNameError | import("./mcp-server-errors.ts").LitellmMcpServerUnreadableError | 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/mcp_management").UnprocessableEntity, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    diff: ({ news, output, }: {
+        news: Input<McpServerProps>;
+        output: McpServerAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'replace';
+        readonly deleteFirst: false;
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'noop';
+    } | {
+        readonly deleteFirst?: never;
+        readonly action: 'update';
+    } | undefined, LitellmMcpServerInvalidError, never>;
+    reconcile: ({ id, instanceId, news, output }: Args<{
+        news: McpServerProps;
+    }>) => Effect.Effect<{
+        serverId: string;
+        serverName: string | null;
+        alias: string | null;
+        url: string | null;
+        transport: string;
+        authType: string;
+        description: string | null;
+        allowAllKeys: boolean;
+        allowedTools: readonly string[];
+        mcpAccessGroups: readonly string[];
+        credentialSeal: string;
+    }, 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 | LitellmMcpServerAbsentAfterWriteError | import("./mcp-server-errors.ts").LitellmMcpServerAmbiguousNameError | import("./mcp-server-errors.ts").LitellmMcpServerCredentialEnvUnsetError | import("./mcp-server-errors.ts").LitellmMcpServerDescriptionShadowedError | LitellmMcpServerInvalidError | LitellmMcpServerNotConvergedError | import("./mcp-server-errors.ts").LitellmMcpServerUnreadableError | 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/mcp_management").UnprocessableEntity, import("alchemy").InstanceId | import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    delete: ({ output }: {
+        output: McpServerAttributes;
+    }) => Effect.Effect<void, import("@distilled.cloud/litellm/mcp_management").RemoveMcpServerV1McpServerServerIdDeleteError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+    /** ⛔ EMPTY: adoption is an explicit act (`--adopt`), and no ownership mark exists to filter by. */
+    list: () => Effect.Effect<never[], never, never>;
+};
+export declare const LiteLLMMCPServerProvider: () => import("effect/Layer").Layer<Provider.Provider<LiteLLMMCPServer>, never, import("alchemy").Stack | import("alchemy").Stage | import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=mcp-server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../src/litellm/mcp-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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;AAExC,OAAO,EACL,qCAAqC,EACrC,4BAA4B,EAC5B,iCAAiC,EAClC,MAAM,wBAAwB,CAAC;AAuBhC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAEpB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,mBAAmB,EAAE,cAAc,EAAE,CAAC;AACpD,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,gBAAiB,SAAQ,QAAQ,CAChD,mBAAmB,EACnB,cAAc,EACd,mBAAmB,CACpB;CAAG;AAEJ,eAAO,MAAM,gBAAgB,mDAE3B,CAAC;AAEH,eAAO,MAAM,kBAAkB,UAAW,OAAO,KAAG,KAAK,IAAI,gBACe,CAAC;AAW7E,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACzC,GAAG,CAAC,CAAC;AAEN,oDAAoD;AACpD,eAAO,MAAM,iBAAiB;IAC5B;;;;;;;;;;;;OAYG;IACH,IAAI,qCAAqC,IAAI,CAAC;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC;IAmBvE,IAAI,sBAGD;QACD,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QAC5B,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;KACzC;yBAOsB,SAAS;;;;yBAIb,MAAM;;;yBACN,QAAQ;;IAG3B,SAAS,qCAAqC,IAAI,CAAC;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC;;;;;;;;;;;;;IAgE5E,MAAM,eAAe;QAAE,MAAM,EAAE,mBAAmB,CAAA;KAAE;IAEpD,mGAAmG;IACnG,IAAI;CACL,CAAC;AAEF,eAAO,MAAM,wBAAwB,kMAIlC,CAAC"}