@homeflare/alchemy 0.27.4 → 0.29.0

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

@@ -1,31 +1,42 @@
 /**
- * A loopback `Bun.serve` fake of LiteLLM's `/config/pass_through_endpoint` routes — TEST ONLY,
- * never imported by `index.ts` (the netbox/proxmox house convention for test-only helpers).
+ * A fake of LiteLLM's `/config/pass_through_endpoint` routes for tests — TEST ONLY, never imported
+ * by `index.ts` (the netbox/forgejo house convention for test-only helpers). Mirrors
+ * `../netbox/fake-netbox.ts`/`../forgejo/fake-forgejo.ts`: a `fetch` function handed to Effect's
+ * real `FetchHttpClient` through its `Fetch` reference, so a test exercises distilled's REAL path
+ * assembly, JSON encode/decode and status→typed-error matching (`BadRequest`, `NotFound`, …) —
+ * nothing about that matching is re-implemented here, only the wire responses a scenario needs.
  *
  * ★ MODELS THE WHOLE-FIELD READ-MODIFY-WRITE ON PURPOSE. `general_settings.pass_through_endpoints`
- *   is ONE field (client.ts's header), so every mutation here reads the CURRENT row list, waits
- *   (so two concurrent requests can interleave), then writes back what it captured — not what is
- *   there by the time it writes. Two `create` calls that race lose one row, exactly like the
- *   vendor field would without the client's per-base-URL semaphore serialising them.
+ *   is ONE field (operations.ts's header), so every mutation here reads the CURRENT row list,
+ *   awaits (so two concurrent calls can interleave — no real socket needed, `fetch` is just an
+ *   async function the runtime awaits), then writes back what it captured — not what is there by
+ *   the time it writes. Two `create` calls that race lose one row, exactly like the vendor field
+ *   would without `operations.ts`'s per-base-URL semaphore serialising them.
  * ⚠️ WHAT THIS FAKE DOES NOT MODEL: PROXY_ADMIN vs. a lesser role for most routes (any correct
- *   bearer token is accepted); and update-of-a-missing-id, which is not measured at the tag — this
- *   fake 400s it, the same status a missing delete gets, as a documented TEST SIMPLIFICATION, not a
- *   vendor fact (docs/litellm.md says so too). `forbidDelete` is the one exception: it models the
- *   real asymmetry client.ts's header describes — `DELETE` routes through
- *   `update_config_general_settings`, which 400s `not_allowed_access` for a non-PROXY_ADMIN caller
- *   (or a disconnected DB) on a row that is genuinely still live, the SAME status a missing-id
- *   delete gets (proxy_server.py:16389-16416 at v1.100.0).
+ *   bearer token is accepted). `forbidDelete` is the one exception: it models the real asymmetry
+ *   `operations.ts`'s header describes — `DELETE` routes through `update_config_general_settings`,
+ *   which 400s `not_allowed_access` for a non-PROXY_ADMIN caller (or a disconnected DB) on a row
+ *   that is genuinely still live, the SAME status a missing-id delete gets (proxy_server.py:
+ *   16389-16416 at v1.100.0).
+ * ⚠️ UPDATE-OF-A-MISSING-ID IS 404, NOT 400 — corrected by this migration. The retired hand-rolled
+ *   fake 400'd it as "not measured at the tag, a documented test simplification". The distilled
+ *   SDK's own `patches/misc/update_pass_through_endpoints_*.json` cites the real source
+ *   (`pass_through_endpoints.py`'s `update_pass_through_endpoints` at the tag): unlike DELETE, this
+ *   route raises a genuine, unambiguous `HTTPException(404)` for a missing id, distinct from the
+ *   400 `update_config_general_settings` raises for the trailing auth/DB-disconnected write. This
+ *   fake now matches that measured vendor behaviour.
  */
-import type { PassThroughGenericEndpoint } from './generated/pass-through.ts';
+import type { PassThroughGenericEndpoint } from '@distilled.cloud/litellm/misc';
+/** RFC 2606 placeholder — never a real host. Shared across tests, like `../netbox/fake-netbox.ts`. */
+export declare const FAKE_BASE = "https://litellm.example.com";
 export interface FakeRequest {
     readonly method: string;
     readonly path: string;
 }
 export interface FakeLitellm {
-    readonly url: string;
+    readonly fetch: typeof globalThis.fetch;
     readonly rows: () => readonly PassThroughGenericEndpoint[];
     readonly requests: () => readonly FakeRequest[];
-    readonly stop: () => void;
 }
 export declare const startFakeLitellm: (options?: {
     readonly masterKey?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"fake-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAE9E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,0BAA0B,EAAE,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;CAC3B;AAKD,eAAO,MAAM,gBAAgB,aAAc;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IACtD,qGAAqG;IACrG,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC,KAAG,WA2EH,CAAC"}
+{"version":3,"file":"fake-litellm.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-litellm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAEhF,sGAAsG;AACtG,eAAO,MAAM,SAAS,gCAAgC,CAAC;AAEvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,0BAA0B,EAAE,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;CACjD;AAQD,eAAO,MAAM,gBAAgB,aAAc;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IACtD,qGAAqG;IACrG,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC,KAAG,WAiEH,CAAC"}

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

@@ -1,5 +1,4 @@
 import * as Effect from 'effect/Effect';
-import { type LitellmCreds } from './credentials.ts';
 /** The planned action for each resource, deletions included, keyed by FQN. */
 export type Planned = Readonly<Record<string, string>>;
 /** A stack body: resource declarations, as an `alchemy.run.ts` would write them. */
@@ -15,13 +14,19 @@ export interface FakeStack {
 /**
  * ⚠️ CREDENTIALS/HTTPCLIENT ARE PROVIDED AROUND `deploy`, NOT BAKED INTO THE PROVIDER LAYER.
  *   `Provider.effect`'s own construction effect is `Effect.succeed(...)` (pass-through-endpoint.ts)
- *   — it never actually reads `LitellmCredentials`/`HttpClient`; only the HANDLERS it returns do,
- *   and those run later, whenever `Apply.ts` calls `provider.reconcile`/`read`/`delete`. Effect
+ *   — it never actually reads `Credentials`/`HttpClient`; only the HANDLERS it returns do, and
+ *   those run later, whenever `Apply.ts` calls `provider.reconcile`/`read`/`delete`. Effect
  *   resolves a `yield*`'s service from whatever ambient context wraps the CALL SITE, so the layers
  *   those handlers need must wrap the whole plan+apply pipeline below, exactly where openbao's
  *   fake-stack.ts wraps `BaoEnv` around its own `deploy`.
+ * ★ `fetchFn` IS `startFakeLitellm(...).fetch` (fake-litellm.ts) — this harness never opens a real
+ *   socket; `FetchHttpClient.Fetch` is the seam the SDK's protocol layer calls through, same as
+ *   `../netbox/fake-netbox.ts`'s `fakeNetboxLayer`.
  */
-export declare const fakeStack: (creds: LitellmCreds, name?: string) => FakeStack;
+export declare const fakeStack: (creds: {
+    readonly apiKey: string;
+    readonly baseUrl: string;
+}, fetchFn: typeof globalThis.fetch, name?: string) => FakeStack;
 /** Every call that changed something, as `METHOD path`, in order. */
 export declare const writesOf: (requests: readonly {
     readonly method: string;

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

@@ -1 +1 @@
-{"version":3,"file":"fake-stack.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-stack.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,KAAK,YAAY,EAA8B,MAAM,kBAAkB,CAAC;AAGjF,8EAA8E;AAC9E,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvD,oFAAoF;AACpF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEjE,6FAA6F;AAC7F,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjF;AAiBD;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,UAAW,YAAY,oBAA8B,SAgC1E,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,QAAQ,aACT,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,KACtE,MAAM,EACsF,CAAC"}
+{"version":3,"file":"fake-stack.d.ts","sourceRoot":"","sources":["../../src/litellm/fake-stack.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,8EAA8E;AAC9E,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvD,oFAAoF;AACpF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEjE,6FAA6F;AAC7F,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjF;AAiBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,UACb;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,WACnD,OAAO,UAAU,CAAC,KAAK,oBAE/B,SAiCF,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,QAAQ,aACT,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,KACtE,MAAM,EACsF,CAAC"}

package/dist/litellm/index.d.ts

@@ -2,12 +2,14 @@
  * LiteLLM providers for Alchemy.
  *
  * ⛔ THIS BARREL IS THE PUBLIC API, deliberately smaller than the directory — `fake-litellm.ts`
- *   and the internals `pass-through-form.ts`/`client.ts` need but a consumer should not depend on
- *   directly are not re-exported here (netbox/index.ts's own rule).
+ *   and the internals `pass-through-form.ts`/`operations.ts` need but a consumer should not depend
+ *   on directly are not re-exported here (netbox/index.ts's own rule).
+ * ★ CREDENTIALS AND TYPES NOW COME FROM `@distilled.cloud/litellm` ITSELF (2026-09-24, moved off a
+ *   hand-rolled `client.ts`/`credentials.ts` the same way `/netbox` and `/forgejo` did) — a
+ *   consumer building its own credentials layer imports `Credentials`/`CredentialsFromEnv`/
+ *   `credentials` from `@distilled.cloud/litellm/Credentials` directly, not through this barrel.
  */
-export { LITELLM_PROXY_API_KEY_ENV, LITELLM_PROXY_URL_ENV, LitellmCredentials, type LitellmCreds, LitellmCredentialsError, litellmCredentialsLayer, litellmCredentialsLayerFor, } from './credentials.ts';
-export { LITELLM_OPERATIONS, LitellmBadRequestError, type LitellmError, LitellmHttpError, type LitellmRequirements, LitellmTransportError, LitellmUnauthorizedError, } from './client.ts';
-export type { PassThroughEndpointResponse, PassThroughGenericEndpoint, PassThroughGuardrailSettings, } from './generated/pass-through.ts';
+export type { PassThroughEndpointResponse, PassThroughGenericEndpoint, PassThroughGuardrailSettings, } from '@distilled.cloud/litellm/misc';
 export { LiteLLMPassThroughEndpoint, LiteLLMPassThroughEndpointProvider, LitellmConfigPathConflictError, LitellmLiteralSecretHeaderError, LitellmUnaddressableRowError, isLiteLLMPassThroughEndpoint, type PassThroughEndpointAttributes, type PassThroughEndpointError, type PassThroughEndpointProps, } from './pass-through-endpoint.ts';
 export { litellmProviders } from './providers.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/litellm/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,kBAAkB,EAClB,KAAK,YAAY,EACjB,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,YAAY,EACjB,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,4BAA4B,EAC5B,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,GAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/litellm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,YAAY,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,4BAA4B,EAC5B,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,GAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/litellm/index.js

@@ -1,57 +1,19 @@
-// src/litellm/credentials.ts
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-var LITELLM_PROXY_URL_ENV = "LITELLM_PROXY_URL";
-var LITELLM_PROXY_API_KEY_ENV = "LITELLM_PROXY_API_KEY";
-
-class LitellmCredentialsError extends Data.TaggedError("LitellmCredentialsError") {
-}
-var missing = (name) => new LitellmCredentialsError({
-  message: `${name} is not set. Export it — the same variable LiteLLM's own \`litellm\` CLI ` + "reads — before running a stack that declares a LiteLLM.PassThroughEndpoint."
-});
-var resolveCreds = Effect.gen(function* () {
-  const rawUrl = process.env[LITELLM_PROXY_URL_ENV];
-  if (rawUrl === undefined || rawUrl.trim() === "")
-    return yield* Effect.fail(missing(LITELLM_PROXY_URL_ENV));
-  const rawKey = process.env[LITELLM_PROXY_API_KEY_ENV];
-  if (rawKey === undefined || rawKey.trim() === "") {
-    return yield* Effect.fail(missing(LITELLM_PROXY_API_KEY_ENV));
-  }
-  return { baseUrl: rawUrl.trim().replace(/\/$/, ""), apiKey: rawKey.trim() };
-});
-
-class LitellmCredentials extends Context.Service()("homeflare/litellm/Credentials") {
-}
-var litellmCredentialsLayer = Layer.succeed(LitellmCredentials, resolveCreds);
-var litellmCredentialsLayerFor = (creds) => Layer.succeed(LitellmCredentials, Effect.succeed(creds));
-// src/litellm/client.ts
-import * as Data2 from "effect/Data";
+// src/litellm/pass-through-endpoint.ts
+import { Resource } from "alchemy";
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import { createPhysicalName } from "alchemy/PhysicalName";
+import * as Provider from "alchemy/Provider";
 import * as Effect2 from "effect/Effect";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
-import * as Semaphore from "effect/Semaphore";
-var LITELLM_OPERATIONS = {
-  create: "litellm:POST /config/pass_through_endpoint",
-  delete: "litellm:DELETE /config/pass_through_endpoint",
-  list: "litellm:GET /config/pass_through_endpoint",
-  update: "litellm:POST /config/pass_through_endpoint/{endpoint_id}"
-};
-
-class LitellmUnauthorizedError extends Data2.TaggedError("LitellmUnauthorizedError") {
-}
-
-class LitellmBadRequestError extends Data2.TaggedError("LitellmBadRequestError") {
-}
-
-class LitellmHttpError extends Data2.TaggedError("LitellmHttpError") {
-}
+import * as Predicate from "effect/Predicate";
 
-class LitellmTransportError extends Data2.TaggedError("LitellmTransportError") {
-}
+// src/litellm/operations.ts
+import * as misc from "@distilled.cloud/litellm/misc";
+import { Credentials } from "@distilled.cloud/litellm/Credentials";
+import * as Effect from "effect/Effect";
+import * as Semaphore from "effect/Semaphore";
 var semaphores = new Map;
-var semaphoreFor = (baseUrl) => Effect2.sync(() => {
+var semaphoreFor = (baseUrl) => Effect.sync(() => {
   const existing = semaphores.get(baseUrl);
   if (existing !== undefined)
     return existing;
@@ -59,49 +21,35 @@ var semaphoreFor = (baseUrl) => Effect2.sync(() => {
   semaphores.set(baseUrl, created);
   return created;
 });
-var call = (method, path, body) => Effect2.gen(function* () {
-  const creds = yield* yield* LitellmCredentials;
-  const client = yield* HttpClient.HttpClient;
-  const url = `${creds.baseUrl}${path}`;
-  const request = HttpClientRequest.make(method)(url).pipe(HttpClientRequest.setHeaders({
-    Accept: "application/json",
-    Authorization: `Bearer ${creds.apiKey}`
-  }), body === undefined ? (self) => self : HttpClientRequest.bodyText(JSON.stringify(body), "application/json"));
-  const response = yield* client.execute(request).pipe(Effect2.mapError((cause) => new LitellmTransportError({ cause: String(cause), method, path })));
-  const text = yield* response.text.pipe(Effect2.mapError((cause) => new LitellmTransportError({ cause: String(cause), method, path })));
-  if (response.status === 401 || response.status === 403) {
-    return yield* Effect2.fail(new LitellmUnauthorizedError({ method, path, status: response.status }));
-  }
-  if (response.status === 400) {
-    return yield* Effect2.fail(new LitellmBadRequestError({ detail: text.slice(0, 300), method, path }));
-  }
-  if (response.status < 200 || response.status >= 300) {
-    return yield* Effect2.fail(new LitellmHttpError({ detail: text.slice(0, 300), method, path, status: response.status }));
-  }
-  return text === "" ? undefined : JSON.parse(text);
-});
-var listPassThroughEndpoints = () => call("GET", "/config/pass_through_endpoint").pipe(Effect2.map((body) => body.endpoints));
-var mutate = (io) => Effect2.gen(function* () {
-  const creds = yield* yield* LitellmCredentials;
-  const semaphore = yield* semaphoreFor(creds.baseUrl);
+var mutate = (io) => Effect.gen(function* () {
+  const resolve = yield* Credentials;
+  const creds = yield* resolve;
+  const semaphore = yield* semaphoreFor(creds.apiBaseUrl);
   return yield* semaphore.withPermits(1)(io);
 });
-var createPassThroughEndpoint = (body) => mutate(call("POST", "/config/pass_through_endpoint", body));
-var updatePassThroughEndpoint = (endpointId, body) => mutate(call("POST", `/config/pass_through_endpoint/${encodeURIComponent(endpointId)}`, body));
-var deletePassThroughEndpoint = (endpointId) => mutate(call("DELETE", `/config/pass_through_endpoint?endpoint_id=${encodeURIComponent(endpointId)}`).pipe(Effect2.catchTag("LitellmBadRequestError", (original) => Effect2.gen(function* () {
+var listPassThroughEndpoints = () => misc.getPassThroughEndpointsConfigPassThroughEndpointGet({}).pipe(Effect.map((response) => response.endpoints));
+var createPassThroughEndpoint = (body) => mutate(misc.createPassThroughEndpointsConfigPassThroughEndpointPost(body).pipe(Effect.asVoid));
+var updatePassThroughEndpoint = (endpointId, body) => mutate(misc.updatePassThroughEndpointsConfigPassThroughEndpointEndpointIdPost({
+  ...body,
+  endpoint_id: endpointId
+}).pipe(Effect.asVoid));
+var deletePassThroughEndpoint = (endpointId) => mutate(misc.deletePassThroughEndpointsConfigPassThroughEndpointDelete({ endpoint_id: endpointId }).pipe(Effect.asVoid, Effect.catchTag("BadRequest", (original) => Effect.gen(function* () {
   const rows = yield* listPassThroughEndpoints();
   if (rows.some((row) => row.id === endpointId))
-    return yield* Effect2.fail(original);
-})), Effect2.asVoid));
-// src/litellm/pass-through-endpoint.ts
-import { Resource } from "alchemy";
-import { Unowned } from "alchemy/AdoptPolicy";
-import { isResolved } from "alchemy/Diff";
-import { createPhysicalName } from "alchemy/PhysicalName";
-import * as Provider from "alchemy/Provider";
-import * as Data3 from "effect/Data";
-import * as Effect3 from "effect/Effect";
-import * as Predicate from "effect/Predicate";
+    return yield* Effect.fail(original);
+}))));
+
+// src/litellm/pass-through-errors.ts
+import * as Data from "effect/Data";
+
+class LitellmConfigPathConflictError extends Data.TaggedError("LitellmConfigPathConflictError") {
+}
+
+class LitellmUnaddressableRowError extends Data.TaggedError("LitellmUnaddressableRowError") {
+}
+
+class LitellmLiteralSecretHeaderError extends Data.TaggedError("LitellmLiteralSecretHeaderError") {
+}
 
 // src/litellm/pass-through-form.ts
 import { deepEqual } from "alchemy/Diff";
@@ -141,14 +89,6 @@ var SECRET_HEADER_NAMES = new Set(["authorization", "x-api-key", "cf-aig-authori
 var literalSecretHeaders = (headers) => Object.entries(headers ?? {}).filter(([name, value]) => SECRET_HEADER_NAMES.has(name.toLowerCase()) && !String(value).includes("os.environ/")).map(([name]) => name);
 
 // src/litellm/pass-through-endpoint.ts
-class LitellmConfigPathConflictError extends Data3.TaggedError("LitellmConfigPathConflictError") {
-}
-
-class LitellmUnaddressableRowError extends Data3.TaggedError("LitellmUnaddressableRowError") {
-}
-
-class LitellmLiteralSecretHeaderError extends Data3.TaggedError("LitellmLiteralSecretHeaderError") {
-}
 var LiteLLMPassThroughEndpoint = Resource("LiteLLM.PassThroughEndpoint");
 var isLiteLLMPassThroughEndpoint = (value) => Predicate.hasProperty(value, "Type") && value.Type === "LiteLLM.PassThroughEndpoint";
 var toAttributes = (row, fallbackId) => ({
@@ -162,10 +102,10 @@ var locate = (rows, objectId, path) => {
   return { conflict, mine };
 };
 var conflictRefusal = (conflict, path) => conflict.is_from_config === true ? new LitellmConfigPathConflictError({ path }) : new LitellmUnaddressableRowError({ path });
-var readConflict = (conflict, path) => conflict.is_from_config !== true && conflict.id !== undefined && conflict.id !== null ? Effect3.succeed(Unowned(toAttributes(conflict, conflict.id))) : Effect3.fail(conflictRefusal(conflict, path));
+var readConflict = (conflict, path) => conflict.is_from_config !== true && conflict.id !== undefined && conflict.id !== null ? Effect2.succeed(Unowned(toAttributes(conflict, conflict.id))) : Effect2.fail(conflictRefusal(conflict, path));
 var refuseLiteralSecrets = (headers) => {
   const bad = literalSecretHeaders(headers);
-  return bad.length === 0 ? Effect3.void : Effect3.fail(new LitellmLiteralSecretHeaderError({ headers: bad }));
+  return bad.length === 0 ? Effect2.void : Effect2.fail(new LitellmLiteralSecretHeaderError({ headers: bad }));
 };
 var passThroughHandlers = {
   read: ({
@@ -173,7 +113,7 @@ var passThroughHandlers = {
     instanceId,
     olds,
     output
-  }) => Effect3.gen(function* () {
+  }) => Effect2.gen(function* () {
     const objectId = output?.id ?? (yield* physicalIdOf(id, instanceId));
     const rows = yield* listPassThroughEndpoints();
     const { conflict, mine } = locate(rows, objectId, olds.path);
@@ -186,7 +126,7 @@ var passThroughHandlers = {
   diff: ({
     news,
     output
-  }) => Effect3.gen(function* () {
+  }) => Effect2.gen(function* () {
     if (!isResolved(news))
       return;
     yield* refuseLiteralSecrets(news.headers);
@@ -201,17 +141,17 @@ var passThroughHandlers = {
     instanceId,
     news,
     output
-  }) => Effect3.gen(function* () {
+  }) => Effect2.gen(function* () {
     yield* refuseLiteralSecrets(news.headers);
     const objectId = output?.id ?? (yield* physicalIdOf(id, instanceId));
     const rows = yield* listPassThroughEndpoints();
     const { conflict, mine } = locate(rows, objectId, news.path);
     if (mine === undefined) {
       if (conflict !== undefined)
-        return yield* Effect3.fail(conflictRefusal(conflict, news.path));
+        return yield* Effect2.fail(conflictRefusal(conflict, news.path));
       yield* createPassThroughEndpoint(createBody(news, objectId));
     } else if (mine.is_from_config === true) {
-      return yield* Effect3.fail(new LitellmConfigPathConflictError({ path: news.path }));
+      return yield* Effect2.fail(new LitellmConfigPathConflictError({ path: news.path }));
     } else if (needsReplace(toAttributes(mine, objectId), news)) {
       yield* deletePassThroughEndpoint(objectId);
       yield* createPassThroughEndpoint(createBody(news, objectId));
@@ -222,7 +162,7 @@ var passThroughHandlers = {
     }
     const after = (yield* listPassThroughEndpoints()).find((row) => row.id === objectId);
     if (after === undefined) {
-      return yield* Effect3.die(new Error(`LiteLLM.PassThroughEndpoint ${news.path}: the write returned no error but id ` + `${objectId} is still absent from GET /config/pass_through_endpoint — read back ` + "rather than trusting the call that just returned."));
+      return yield* Effect2.die(new Error(`LiteLLM.PassThroughEndpoint ${news.path}: the write returned no error but id ` + `${objectId} is still absent from GET /config/pass_through_endpoint — read back ` + "rather than trusting the call that just returned."));
     }
     return toAttributes(after, objectId);
   }),
@@ -231,7 +171,7 @@ var passThroughHandlers = {
     instanceId,
     olds,
     output
-  }) => Effect3.gen(function* () {
+  }) => Effect2.gen(function* () {
     const objectId = output.id ?? (yield* physicalIdOf(id, instanceId));
     const rows = yield* listPassThroughEndpoints();
     const live = rows.find((row) => row.id === objectId);
@@ -239,32 +179,22 @@ var passThroughHandlers = {
       return;
     yield* deletePassThroughEndpoint(objectId);
   }),
-  list: () => Effect3.succeed([])
+  list: () => Effect2.succeed([])
 };
-var LiteLLMPassThroughEndpointProvider = () => Provider.effect(LiteLLMPassThroughEndpoint, Effect3.succeed(LiteLLMPassThroughEndpoint.Provider.of(passThroughHandlers)));
+var LiteLLMPassThroughEndpointProvider = () => Provider.effect(LiteLLMPassThroughEndpoint, Effect2.succeed(LiteLLMPassThroughEndpoint.Provider.of(passThroughHandlers)));
 // src/litellm/providers.ts
-import * as Layer2 from "effect/Layer";
-var litellmProviders = (creds = litellmCredentialsLayer) => LiteLLMPassThroughEndpointProvider().pipe(Layer2.provide(creds));
+import { CredentialsFromEnv } from "@distilled.cloud/litellm/Credentials";
+import * as Layer from "effect/Layer";
+var litellmProviders = (creds = CredentialsFromEnv) => LiteLLMPassThroughEndpointProvider().pipe(Layer.provide(creds));
 export {
-  LITELLM_OPERATIONS,
-  LITELLM_PROXY_API_KEY_ENV,
-  LITELLM_PROXY_URL_ENV,
   LiteLLMPassThroughEndpoint,
   LiteLLMPassThroughEndpointProvider,
-  LitellmBadRequestError,
   LitellmConfigPathConflictError,
-  LitellmCredentials,
-  LitellmCredentialsError,
-  LitellmHttpError,
   LitellmLiteralSecretHeaderError,
-  LitellmTransportError,
   LitellmUnaddressableRowError,
-  LitellmUnauthorizedError,
   isLiteLLMPassThroughEndpoint,
-  litellmCredentialsLayer,
-  litellmCredentialsLayerFor,
   litellmProviders
 };
 
-//# debugId=9216FE33E5E3721264756E2164756E21
+//# debugId=F883BA858F0CF3AD64756E2164756E21
 //# sourceMappingURL=index.js.map