@homeflare/alchemy 0.42.0 → 0.44.0

package/src/litellm/credential-recovery.test.ts

@@ -0,0 +1,93 @@
+/** A failed rewrite must describe the completed DELETE and recover on the next real deploy. */
+import { expect, test } from 'bun:test';
+import * as Effect from 'effect/Effect';
+import { type CredentialProps, LiteLLMCredential, credentialHandlers } from './credential.ts';
+import { startFakeCredentialLitellm } from './fake-credential-litellm.ts';
+import { fakeStack, writesOf } from './fake-stack.ts';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { FAKE_KEY, MASTER_KEY, failureOf, newFake, runAgainst, withEnv } from './key-harness.ts';
+
+const variable = 'FAKE_RECOVERY_KEY';
+const props: CredentialProps = {
+  credentialName: 'recovery',
+  credentialInfo: { note: 'search' },
+  credentialValues: { api_key: { fromEnv: variable } },
+};
+const original = { ...props, credentialInfo: { ...props.credentialInfo, extra: 'remove' } };
+const declare = (news: CredentialProps) =>
+  Effect.gen(function* () {
+    yield* LiteLLMCredential('Cred', news);
+  });
+
+for (const mode of ['transport', 'forbidden', 'validation'] as const) {
+  test(`a rewrite POST ${mode} failure reports DELETE and the next deploy recreates`, async () => {
+    const fake = startFakeCredentialLitellm({ masterKey: MASTER_KEY });
+    let failPost = false;
+    let postsFailed = 0;
+    const fetch = (async (input, init) => {
+      const request =
+        input instanceof Request ? new Request(input, init) : new Request(String(input), init);
+      if (
+        failPost &&
+        request.method === 'POST' &&
+        new URL(request.url).pathname === '/credentials'
+      ) {
+        postsFailed += 1;
+        if (mode === 'transport') throw new TypeError('connection dropped');
+        return new Response(JSON.stringify({ detail: 'replacement rejected' }), {
+          status: mode === 'forbidden' ? 403 : 422,
+          headers: { 'content-type': 'application/json' },
+        });
+      }
+      return fake.fetch(request);
+    }) as typeof globalThis.fetch;
+    const engine = fakeStack({ apiKey: MASTER_KEY, baseUrl: FAKE_BASE }, fetch, 'Recovery', {
+      noRetry: true,
+    });
+    await withEnv({ [variable]: FAKE_KEY }, async () => {
+      await engine.deploy(declare(original));
+      failPost = true;
+      const message = await failureOf(engine.deploy(declare(props)));
+      expect(message).toContain('DELETE already ran');
+      expect(message).toContain('next deploy recreates');
+      expect(message.includes(FAKE_KEY)).toBe(false);
+      expect(postsFailed).toBe(1);
+      expect(fake.rows()).toHaveLength(0);
+      expect(writesOf(fake.requests())).toEqual([
+        'POST /credentials',
+        'DELETE /credentials/recovery',
+      ]);
+      failPost = false;
+      await engine.deploy(declare(props));
+      expect(fake.rows()).toHaveLength(1);
+      expect(fake.rows()[0]?.credential_info).toEqual(props.credentialInfo);
+      expect(await engine.deploy(declare(props))).toEqual({ Cred: 'noop' });
+      expect(engine.snapshot().includes(FAKE_KEY)).toBe(false);
+
+      // The same failure is catchable in the error channel, with no request or cause retained.
+      await engine.deploy(declare(original));
+      failPost = true;
+      const error = await runAgainst(
+        { ...newFake(), fetch },
+        credentialHandlers
+          .reconcile({
+            fqn: 'Cred',
+            instanceId: 'i-1',
+            news: props,
+            output: {
+              credentialName: props.credentialName,
+              credentialInfo: original.credentialInfo,
+              valuesSeal: '',
+            },
+          })
+          .pipe(
+            Effect.catchTag('LitellmCredentialRewriteError', (failure) => Effect.succeed(failure)),
+          ),
+      );
+      expect('_tag' in error && error._tag).toBe('LitellmCredentialRewriteError');
+      expect(JSON.stringify(error).includes(FAKE_KEY)).toBe(false);
+      expect('cause' in error).toBe(false);
+      expect('request' in error).toBe(false);
+    });
+  });
+}

package/src/litellm/credential-rewrite.test.ts

@@ -0,0 +1,164 @@
+/** Removal needs both LiteLLM stores to converge; preflight must finish before DELETE. */
+import { afterEach, beforeEach, expect, test } from 'bun:test';
+import { credentials } from '@distilled.cloud/litellm/Credentials';
+import * as Effect from 'effect/Effect';
+import * as FetchHttpClient from 'effect/unstable/http/FetchHttpClient';
+import { type CredentialProps, LiteLLMCredential, credentialHandlers } from './credential.ts';
+import { credentialRow, startFakeCredentialLitellm } from './fake-credential-litellm.ts';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { fakeStack, writesOf } from './fake-stack.ts';
+
+const variable = 'FAKE_REWRITE_KEY';
+const creds = { apiKey: 'FAKE-master', baseUrl: FAKE_BASE };
+const props: CredentialProps = {
+  credentialName: 'FAKE_api',
+  credentialInfo: { note: 'search' },
+  credentialValues: { api_key: { fromEnv: variable } },
+};
+const declare = (news: CredentialProps) =>
+  Effect.gen(function* () {
+    yield* LiteLLMCredential('Cred', news);
+  });
+const extraValues = {
+  ...props,
+  credentialValues: {
+    ...props.credentialValues,
+    api_base: { fromEnv: variable },
+  },
+};
+const extraInfo = { ...props, credentialInfo: { ...props.credentialInfo, team: 'a' } };
+const setup = () => {
+  const fake = startFakeCredentialLitellm({ masterKey: creds.apiKey });
+  return { fake, engine: fakeStack(creds, fake.fetch) };
+};
+beforeEach(() => {
+  process.env[variable] = 'FAKE-rewrite-value';
+});
+afterEach(() => {
+  delete process.env[variable];
+  delete process.env.DISTILLED_DEBUG_HTTP;
+});
+
+test('dropping a value key rewrites the row, removes it from DB and memory, then noops', async () => {
+  const { fake, engine } = setup();
+  await engine.deploy(declare(extraValues));
+  const before = fake.requests().length;
+  expect(await engine.deploy(declare(props))).toEqual({ Cred: 'update' });
+  expect(writesOf(fake.requests().slice(before))).toEqual([
+    'DELETE /credentials/FAKE_api',
+    'POST /credentials',
+  ]);
+  expect(Object.keys(fake.rows()[0]?.credential_values as object)).toEqual(['api_key']);
+  expect(await engine.deploy(declare(props))).toEqual({ Cred: 'noop' });
+  expect(engine.snapshot().includes('FAKE-rewrite-value')).toBe(false);
+});
+
+for (const [kind, original] of [
+  ['value', extraValues],
+  ['info', extraInfo],
+] as const) {
+  test(`dropping a ${kind} key with a missing value refuses before DELETE`, async () => {
+    const { fake, engine } = setup();
+    await engine.deploy(declare(original));
+    const before = fake.requests().length;
+    delete process.env[variable];
+    await expect(engine.deploy(declare(props))).rejects.toThrow(variable);
+    expect(writesOf(fake.requests().slice(before))).toEqual([]);
+    expect(fake.rows()).toHaveLength(1);
+  });
+
+  test(`dropping a ${kind} key under debug logging refuses before any reconcile request`, async () => {
+    const { fake, engine } = setup();
+    await engine.deploy(declare(original));
+    // The refusal is before any observation or write, so even stale state cannot bypass it.
+    const before = fake.requests().length;
+    process.env.DISTILLED_DEBUG_HTTP = '1';
+    const error = await Effect.runPromise(
+      credentialHandlers
+        .reconcile({
+          fqn: 'Cred',
+          instanceId: 'i-1',
+          news: props,
+          output: {
+            credentialName: props.credentialName,
+            credentialInfo: original.credentialInfo ?? {},
+            valuesSeal: '',
+          },
+        })
+        .pipe(
+          Effect.catchTag('LitellmCredentialDebugLoggingError', (failure) =>
+            Effect.succeed(failure._tag),
+          ),
+          Effect.provide(FetchHttpClient.layer),
+          Effect.provideService(FetchHttpClient.Fetch, fake.fetch),
+          Effect.provide(credentials(creds)),
+        ),
+    );
+    expect(error).toBe('LitellmCredentialDebugLoggingError');
+    expect(fake.requests()).toHaveLength(before);
+    expect(fake.rows()).toHaveLength(1);
+  });
+}
+
+test('adoption deliberately removes undeclared info keys, including withheld sensitive names', async () => {
+  const fake = startFakeCredentialLitellm({
+    masterKey: creds.apiKey,
+    seed: [
+      credentialRow({
+        credential_name: props.credentialName,
+        credential_info: { note: 'search', foreign: 'a', secret: 'FAKE-withheld' },
+        credential_values: { api_key: 'FAKE-existing' },
+      }),
+    ],
+  });
+  const engine = fakeStack(creds, fake.fetch);
+  await engine.deploy(declare(props), { adopt: true });
+  expect(writesOf(fake.requests())).toEqual(['DELETE /credentials/FAKE_api', 'POST /credentials']);
+  expect(Object.keys(fake.rows()[0]?.credential_info as object)).toEqual(['note']);
+  expect(engine.snapshot().includes('FAKE-withheld')).toBe(false);
+  expect(await engine.deploy(declare(props))).toEqual({ Cred: 'noop' });
+});
+
+test('PATCH records a complete intended info map and the required body name', async () => {
+  const { fake, engine } = setup();
+  await engine.deploy(declare(extraInfo));
+  const news = { ...extraInfo, credentialInfo: { note: 'changed', team: 'a' } };
+  await engine.deploy(declare(news));
+  expect(fake.bodies()[1]?.credential_name).toBe(props.credentialName);
+  expect(fake.bodies()[1]?.credential_info).toEqual(news.credentialInfo);
+  expect(fake.rows()[0]?.credential_info).toEqual(news.credentialInfo);
+  expect(await engine.deploy(declare(news))).toEqual({ Cred: 'noop' });
+});
+
+test('the fake rejects a PATCH with no body credential_name, matching UpdateCredentialItem', async () => {
+  const { fake, engine } = setup();
+  await engine.deploy(declare(props));
+  const response = await fake.fetch(`${FAKE_BASE}/credentials/FAKE_api`, {
+    method: 'PATCH',
+    headers: { authorization: `Bearer ${creds.apiKey}`, 'content-type': 'application/json' },
+    body: JSON.stringify({ credential_info: { note: 'changed' } }),
+  });
+  expect(response.status).toBe(422);
+  expect(fake.bodies()).toHaveLength(2);
+  expect(fake.rows()[0]?.credential_info).toEqual(props.credentialInfo);
+});
+
+test('a debug-enabled plan refuses before the read response can print unmasked values', async () => {
+  const { fake, engine } = setup();
+  await engine.deploy(declare(extraValues));
+  const before = fake.requests().length;
+  const printed: string[] = [];
+  const original = console.error;
+  console.error = (...args: unknown[]) => {
+    printed.push(args.join(' '));
+  };
+  try {
+    process.env.DISTILLED_DEBUG_HTTP = '1';
+    await expect(engine.deploy(declare(props))).rejects.toThrow('DISTILLED_DEBUG_HTTP');
+  } finally {
+    console.error = original;
+  }
+  expect(printed.join('\n').includes('FAKE-rewrite-value')).toBe(false);
+  expect(fake.requests()).toHaveLength(before);
+  expect(fake.rows()).toHaveLength(1);
+});

package/src/litellm/credential-rewrite.ts

@@ -0,0 +1,50 @@
+/** Whole-row removal needs a diagnostic that remembers DELETE succeeded before POST failed. */
+import type { API_ERRORS } from '@distilled.cloud/litellm/Errors';
+import type * as credentials from '@distilled.cloud/litellm/credential_management';
+import * as Effect from 'effect/Effect';
+import {
+  LitellmCredentialRewriteError,
+  type LitellmCredentialTransportError,
+} from './credential-errors.ts';
+import { createCredential, deleteCredential } from './credential-operations.ts';
+import type { LitellmOpContext } from './operations.ts';
+
+export const rewriteCredential = (body: credentials.CreateCredentialCredentialsPostRequest) =>
+  Effect.gen(function* () {
+    const credentialName = body.credential_name;
+    yield* deleteCredential(credentialName);
+    // The SDK's status fallback can emit every API_ERRORS member, including statuses absent
+    // from this operation's generated union. Keep only its tag, never a body/message/cause.
+    const post: Effect.Effect<
+      void,
+      | credentials.CreateCredentialCredentialsPostError
+      | LitellmCredentialTransportError
+      | InstanceType<(typeof API_ERRORS)[number]>,
+      LitellmOpContext
+    > = createCredential(body);
+    yield* post.pipe(
+      Effect.catchTag(
+        [
+          'BadGateway',
+          'BadRequest',
+          'ConfigError',
+          'Conflict',
+          'Forbidden',
+          'GatewayTimeout',
+          'HttpClientError',
+          'InternalServerError',
+          'LitellmCredentialTransportError',
+          'LitellmParseError',
+          'Locked',
+          'NotFound',
+          'ServiceUnavailable',
+          'TooManyRequests',
+          'Unauthorized',
+          'UnknownLitellmError',
+          'UnprocessableEntity',
+        ],
+        (error) =>
+          Effect.fail(new LitellmCredentialRewriteError({ credentialName, reason: error._tag })),
+      ),
+    );
+  });

package/src/litellm/credential-types.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 const isBlank = (value: unknown): boolean =>
+  typeof value !== 'string' || value.trim() === '';
+
+/**
+ * The vendor's OWN sensitive-key list, read from the live 1.103.0 container
+ * (`litellm_logging.py::_get_masked_values`): a key containing any of these substrings
+ * (case-insensitive) is masked in every `credential_values` read. Credential-form.ts refuses
+ * them in `credentialInfo` for the same reason the vendor masks them in values.
+ */
+const SENSITIVE_KEY_FRAGMENTS: readonly string[] = [
+  'authorization',
+  'token',
+  'key',
+  'secret',
+  'vertex_credentials',
+  'credentials',
+  'password',
+  'passwd',
+];
+
+/** Whether a key is one the vendor itself treats as sensitive. */
+export const isSensitiveKey = (key: string): boolean => {
+  const lower = key.toLowerCase();
+  return SENSITIVE_KEY_FRAGMENTS.some((fragment) => lower.includes(fragment));
+};

package/src/litellm/credential-values.ts

@@ -0,0 +1,94 @@
+/**
+ * The values of a `LiteLLM.Credential` — resolved from the deploying process's environment at
+ * call time, held as `Redacted`, and compared by seal.
+ *
+ * ★ THIS IS THE CREDENTIAL LITELLM STORES, so the deploying process holds the value: the wire
+ *   body carries the LITERAL (the proxy encrypts it into its database, measured in the live
+ *   1.103.0 container — `credential_endpoints/endpoints.py`'s `encrypt_credential_values`), which
+ *   is exactly why the prop is only a NAME (`credential-types.ts`). Inside this process the value
+ *   is a `Redacted<string>`, so a stray log or error dump prints `<redacted>`; it is unwrapped in
+ *   exactly one place, the wire body (credential-form.ts). Never a prop or an attribute.
+ * ⚠️ LITELLM DOES NOT HAND THE VALUES BACK TO COMPARE WITH: both reads answer them MASKED
+ *   (2 + `****` + 2, `*****` for a short string — `litellm_logging.py::_get_masked_values`), and a
+ *   masked fragment is a partial secret that must never be compared or stored. So what was last
+ *   written is remembered as a SEAL, and a plan asks "are the values in my environment the ones I
+ *   wrote". Four answers, mcp-server-credential.ts's own list:
+ *   - `none`    — no values are declared, nothing to compare.
+ *   - `unknown` — one or more declared variables is unset here, so a plan cannot tell. Never
+ *                 drift: a plan-only environment must not report every credentialed row as
+ *                 changed. A WRITE still demands them (`requireValues`).
+ *   - `stale`   — every 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 exactly these resolved values.
+ * ⚠️ ALL-OR-NOTHING RESOLUTION: a write sends `credential_values` only when EVERY declared
+ *   variable resolves — the values-stale PATCH and the whole-row create both demand every value
+ *   (`requireValues`, credential.ts), because sending the resolved half would store a row whose
+ *   unset half was silently blanked. When any variable is missing the state is `unknown`: an
+ *   info-only PATCH can proceed, but a required rewrite refuses before DELETE.
+ * ⚠️ 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, resolveAll, seal, sealMatches } from '../secrets/write-only.ts';
+import { LitellmCredentialEnvUnsetError } from './credential-errors.ts';
+import type { CredentialProps } from './credential-types.ts';
+
+/** What the environment holds for the declared values. `missing` names the unset variables. */
+export interface ResolvedValues {
+  readonly values: Readonly<Record<string, Redacted.Redacted<string>>>;
+  readonly missing: readonly string[];
+}
+
+export type CredentialValuesState = 'none' | 'unknown' | 'stale' | 'match';
+
+/** ⛔ Reads the environment at CALL time, never at module load (docs/credentials.md). */
+export const resolveValues = (
+  props: CredentialProps,
+  env: Environment = process.env,
+): ResolvedValues => {
+  const { values, missing } = resolveAll(props.credentialValues, env);
+  return {
+    missing,
+    values: Object.fromEntries(
+      Object.entries(values).map(([key, value]) => [key, Redacted.make(value)]),
+    ),
+  };
+};
+
+const sealable = (values: Readonly<Record<string, Redacted.Redacted<string>>>) =>
+  Object.fromEntries(Object.entries(values).map(([key, value]) => [key, Redacted.value(value)]));
+
+/** `scrypt:<salt>:<digest>` of the resolved values, for `valuesSeal`. ⛔ Never a value. */
+export const sealValues = (values: Readonly<Record<string, Redacted.Redacted<string>>>): string =>
+  seal(sealable(values));
+
+export const valuesState = (
+  props: CredentialProps,
+  sealed: string,
+  resolved: ResolvedValues = resolveValues(props),
+): CredentialValuesState => {
+  const declared = Object.keys(props.credentialValues);
+  if (declared.length === 0) return 'none';
+  if (resolved.missing.length > 0) return 'unknown';
+  if (sealed === '') return 'stale';
+  return sealMatches(sealed, sealable(resolved.values)) ? 'match' : 'stale';
+};
+
+/**
+ * Fails naming the missing variables when this write has to send the values and the deploying
+ * process does not hold them all. Creates, rewrites and value-stale PATCHes need every value;
+ * an info-only PATCH leaves values alone and does not need this guard (credential.ts).
+ */
+export const requireValues = (
+  props: CredentialProps,
+  resolved: ResolvedValues,
+): Effect.Effect<void, LitellmCredentialEnvUnsetError> =>
+  resolved.missing.length === 0
+    ? Effect.void
+    : Effect.fail(
+        new LitellmCredentialEnvUnsetError({
+          credentialName: props.credentialName,
+          variables: resolved.missing,
+        }),
+      );