@homeflare/alchemy 0.43.0 → 0.45.0

package/src/litellm/key.test.ts

@@ -0,0 +1,231 @@
+/**
+ * `LiteLLM.Key` through Alchemy's real Plan and Apply over the fake proxy: create, no-op, adopt by
+ * alias, update, and the bind to a `LiteLLM.Budget`. Secret handling is key-secret.test.ts; delete
+ * and read failures are key-delete.test.ts.
+ */
+import { describe, expect, test } from 'bun:test';
+import * as Effect from 'effect/Effect';
+import { LiteLLMBudget } from './budget.ts';
+import { writesOf } from './fake-stack.ts';
+import { LiteLLMKey } from './key.ts';
+import { differing, toAttributes, updateBody } from './key-form.ts';
+import {
+  FAKE_KEY,
+  VAR,
+  declare,
+  failureOf,
+  keyStack,
+  liveRow,
+  newFake,
+  withEnv,
+} from './key-harness.ts';
+
+const tier = (id: string) => ({ budget_id: id, created_at: 'x', updated_at: 'x' });
+const seat = { key: { fromEnv: VAR }, keyAlias: 'seat-a' } as const;
+const deploy = (stack: ReturnType<typeof keyStack>, props: Parameters<typeof declare>[0]) =>
+  withEnv({ [VAR]: FAKE_KEY }, () => stack.deploy(declare(props)));
+const paths = (fake: ReturnType<typeof newFake>) => fake.keys.writes().map((write) => write.path);
+
+describe('create', () => {
+  test('makes the key with every declared setting and sends the value once', async () => {
+    const fake = newFake({ budgetSeed: [tier('hf-tier-agent')] });
+    const props = {
+      ...seat,
+      allowedRoutes: ['/chat/completions'],
+      budgetId: 'hf-tier-agent',
+      metadata: { seat: 'a' },
+      models: ['glm-5.3', 'gpt-oss-120b'],
+      teamId: 'team-cf',
+    };
+    expect(await deploy(keyStack(fake), props)).toEqual({ Seat: 'create' });
+    expect(fake.keys.rows()).toMatchObject([
+      {
+        allowed_routes: ['/chat/completions'],
+        budget_id: 'hf-tier-agent',
+        expires: null,
+        key_alias: 'seat-a',
+        metadata: { seat: 'a' },
+        models: ['glm-5.3', 'gpt-oss-120b'],
+        team_id: 'team-cf',
+      },
+    ]);
+    expect(fake.keys.received()).toEqual([FAKE_KEY]);
+  });
+
+  test('a second deploy of the same declaration writes nothing', async () => {
+    const fake = newFake();
+    const stack = keyStack(fake);
+    await deploy(stack, { ...seat, models: ['glm-5.3'] });
+    const before = fake.requests().length;
+    expect(await deploy(stack, { ...seat, models: ['glm-5.3'] })).toEqual({ Seat: 'noop' });
+    expect(writesOf(fake.requests().slice(before))).toEqual([]);
+  });
+
+  test('binds to a Budget declared beside it: the tier is created first', async () => {
+    const fake = newFake();
+    const planned = await withEnv({ [VAR]: FAKE_KEY }, () =>
+      keyStack(fake).deploy(
+        Effect.gen(function* () {
+          const tierRow = yield* LiteLLMBudget('Tier', { budgetId: 'hf-tier-x', softBudget: 5 });
+          // ★ AN OUTPUT IN A PROP IS A DEPENDENCY EDGE: the fake 400s a key whose `budget_id` is not
+          //   a live budget, so this only succeeds if the Budget was written first.
+          yield* LiteLLMKey('Seat', { ...seat, budgetId: tierRow.budgetId });
+        }),
+      ),
+    );
+    expect(planned).toEqual({ Seat: 'create', Tier: 'create' });
+    expect(writesOf(fake.requests())).toEqual(['POST /budget/new', 'POST /key/generate']);
+    expect(fake.keys.rows()[0]).toMatchObject({ budget_id: 'hf-tier-x' });
+  });
+});
+
+describe('adopt by alias', () => {
+  const live = liveRow({ budget_id: 'hf-tier-agent', models: ['old-model'] });
+  // ★ `budgetId: null` IS DECLARED: an omitted prop is left alone (key-scope.test.ts), so unbinding
+  //   the live tier takes a declaration.
+  const declared = { budgetId: null, keyAlias: 'seat-a', models: ['glm-5.3'] };
+
+  test('a live key with no state is refused without --adopt, and nothing is written', async () => {
+    const fake = newFake({ budgetSeed: [tier('hf-tier-agent')], keySeed: [live] });
+    await expect(keyStack(fake).deploy(declare(declared))).rejects.toThrow();
+    expect(fake.keys.writes()).toEqual([]);
+  });
+
+  test('with --adopt it is taken over and updated, needing no key value', async () => {
+    const fake = newFake({ budgetSeed: [tier('hf-tier-agent')], keySeed: [live] });
+    const planned = await keyStack(fake).deploy(declare(declared), { adopt: true });
+    expect(Object.values(planned)).toEqual(['adopted']);
+    // No `key` in the environment, none in the body: the update finds the key by its alias alone.
+    expect(fake.keys.writes()).toEqual([
+      { body: { budget_id: null, key_alias: 'seat-a', models: ['glm-5.3'] }, path: '/key/update' },
+    ]);
+    expect(fake.keys.rows()[0]).toMatchObject({ budget_id: null, models: ['glm-5.3'] });
+  });
+
+  test('a create the planner could not probe is refused at apply, not taken over', async () => {
+    // `budgetId: tierRow.budgetId` is an Output until the tier exists, so Alchemy skips its
+    // adoption probe for this key — the apply-time check is all that stands between a stray
+    // declaration and a live credential.
+    const fake = newFake({ keySeed: [liveRow({ key_alias: 'seat-a' })] });
+    const body = Effect.gen(function* () {
+      const tierRow = yield* LiteLLMBudget('Tier', { budgetId: 'hf-tier-x', softBudget: 5 });
+      yield* LiteLLMKey('Seat', { keyAlias: 'seat-a', budgetId: tierRow.budgetId });
+    });
+    const message = await failureOf(keyStack(fake).deploy(body));
+    expect(message).toContain('already exists');
+    expect(fake.keys.writes()).toEqual([]);
+    await keyStack(fake).deploy(body, { adopt: true });
+    expect(paths(fake)).toEqual(['/key/update']);
+  });
+});
+
+describe('update', () => {
+  test('changing budget_id sends only that field, and never the key', async () => {
+    const fake = newFake({ budgetSeed: [tier('tier-a'), tier('tier-b')] });
+    const stack = keyStack(fake);
+    await deploy(stack, { ...seat, budgetId: 'tier-a' });
+    expect(await deploy(stack, { ...seat, budgetId: 'tier-b' })).toEqual({ Seat: 'update' });
+    expect(fake.keys.writes().at(-1)).toEqual({
+      body: { budget_id: 'tier-b', key_alias: 'seat-a' },
+      path: '/key/update',
+    });
+    expect(fake.keys.rows()[0]).toMatchObject({ budget_id: 'tier-b' });
+  });
+
+  test('declaring null and [] clears budget_id, models and routes', async () => {
+    const fake = newFake({ budgetSeed: [tier('tier-a')] });
+    const stack = keyStack(fake);
+    await deploy(stack, { ...seat, allowedRoutes: ['/v1/*'], budgetId: 'tier-a', models: ['m'] });
+    await deploy(stack, { ...seat, allowedRoutes: [], budgetId: null, models: [] });
+    expect(fake.keys.rows()[0]).toMatchObject({ allowed_routes: [], budget_id: null, models: [] });
+  });
+
+  test('model order is not a difference', async () => {
+    const fake = newFake();
+    const stack = keyStack(fake);
+    await deploy(stack, { ...seat, models: ['a', 'b'] });
+    expect(await deploy(stack, { ...seat, models: ['b', 'a'] })).toEqual({ Seat: 'noop' });
+  });
+
+  test('a proxy that keeps a field it was told to clear fails the apply', async () => {
+    const fake = newFake({
+      budgetSeed: [tier('hf-tier-agent')],
+      keySeed: [liveRow({ budget_id: 'hf-tier-agent' })],
+      keyUpdateIgnoresNull: true,
+    });
+    const message = await failureOf(
+      keyStack(fake).deploy(declare({ budgetId: null, keyAlias: 'seat-a' }), { adopt: true }),
+    );
+    expect(message).toContain('budget_id');
+  });
+
+  test('renaming the alias is refused before any write', async () => {
+    const fake = newFake();
+    const stack = keyStack(fake);
+    await deploy(stack, seat);
+    const writes = fake.keys.writes().length;
+    const message = await failureOf(deploy(stack, { ...seat, keyAlias: 'seat-b' }));
+    expect(message).toContain('seat-b');
+    expect(fake.keys.writes()).toHaveLength(writes);
+  });
+});
+
+describe('duration', () => {
+  test('is written on create, remembered, and changed or cleared by an update', async () => {
+    const fake = newFake();
+    const stack = keyStack(fake);
+    await deploy(stack, { ...seat, duration: '30d' });
+    expect(fake.keys.rows()[0]?.['expires']).not.toBeNull();
+    expect(await deploy(stack, { ...seat, duration: '30d' })).toEqual({ Seat: 'noop' });
+    expect(await deploy(stack, { ...seat, duration: '7d' })).toEqual({ Seat: 'update' });
+    expect(fake.keys.writes().at(-1)?.body).toEqual({ duration: '7d', key_alias: 'seat-a' });
+    // `duration: null` is the declaration that clears the expiry; leaving it out does not (key-scope.test.ts).
+    expect(await deploy(stack, { ...seat, duration: null })).toEqual({ Seat: 'update' });
+    expect(fake.keys.writes().at(-1)?.body).toEqual({ duration: null, key_alias: 'seat-a' });
+    expect(fake.keys.rows()[0]?.['expires']).toBeNull();
+    expect(await deploy(stack, { ...seat, duration: null })).toEqual({ Seat: 'noop' });
+  });
+
+  test('an adopted key remembers no duration, so declaring one arms it once', async () => {
+    const fake = newFake({ keySeed: [liveRow({ expires: '2099-01-01T00:00:00.000Z' })] });
+    const stack = keyStack(fake);
+    await stack.deploy(declare({ duration: '30d', keyAlias: 'seat-a' }), { adopt: true });
+    expect(fake.keys.writes().at(-1)?.body).toEqual({ duration: '30d', key_alias: 'seat-a' });
+    expect(await stack.deploy(declare({ duration: '30d', keyAlias: 'seat-a' }))).toEqual({
+      Seat: 'noop',
+    });
+  });
+});
+
+describe('form helpers', () => {
+  const row = liveRow({ budget_id: 'tier-a', models: ['a'], metadata: { seat: 'a' } });
+
+  test('toAttributes keeps the compared columns and drops the token hash', () => {
+    const attributes = toAttributes(row);
+    expect(attributes).toEqual({
+      allowedRoutes: [],
+      budgetId: 'tier-a',
+      duration: null,
+      expires: null,
+      keyAlias: 'seat-a',
+      metadata: { seat: 'a' },
+      models: ['a'],
+      teamId: null,
+      withheld: [],
+    });
+    expect(JSON.stringify(attributes)).not.toContain('FAKE-TOKEN');
+  });
+
+  test('differing names the wire fields, and the update body carries only those', () => {
+    const live = toAttributes(row);
+    const props = {
+      budgetId: 'tier-b',
+      keyAlias: 'seat-a',
+      metadata: { seat: 'a' },
+      models: ['a'],
+    };
+    expect(differing(live, props)).toEqual(['budget_id']);
+    expect(updateBody(props, live)).toEqual({ budget_id: 'tier-b', key_alias: 'seat-a' });
+    expect(differing(live, { ...props, budgetId: 'tier-a' })).toEqual([]);
+  });
+});

package/src/litellm/key.ts

@@ -0,0 +1,213 @@
+/**
+ * `LiteLLM.Key` — one virtual key of LiteLLM's `LiteLLM_VerificationToken` (`/key/*`), bound to a
+ * `LiteLLM.Budget` tier, with its value kept out of Alchemy state.
+ *
+ * ★ ADOPT BY ALIAS. `keyAlias` is the identity: `/key/update` and `/key/delete` find a key by it
+ *   (their docstrings), and `/key/list` filters by it, so an existing key is taken over by declaring
+ *   its alias, with no value in hand. A live key with no state is `Unowned` and needs `--adopt`; the
+ *   apply re-checks it (`refuseTakeover`) for a create the planner could not probe — which is EVERY
+ *   key declared with `budgetId: tier.budgetId`, an Output until the tier exists.
+ * ⛔ THE VALUE IS WRITE-ONLY (key-secret.ts): `key: { fromEnv }` names the variable, the value goes
+ *   over the wire once in `/key/generate`, and no attribute, log line or error carries it. `diff`
+ *   checks a set variable against the live token in memory; an unset variable skips the check.
+ *   `read` never touches the environment, and no value or hash is added to state.
+ * ★ `defaultRemovalPolicy: 'retain'` — deleting a key breaks whatever holds it (a seat's every call
+ *   401s). Dropping the declaration leaves the key live; `.pipe(RemovalPolicy.destroy())` opts in.
+ * ⛔ A RENAME IS REFUSED, not replaced. The new key would need the same value, and `/key/generate`
+ *   rejects a second key with a value it already holds; under `retain` the old row would still be
+ *   there. Declare the new alias as a new resource and destroy the old one.
+ * ★ A DECLARATION MANAGES ONLY WHAT IT NAMES (key-form.ts): an omitted prop is never compared or sent,
+ *   and `metadata` is a merge (key-metadata.ts), so an adopted key's scope, budget and guardrails are
+ *   never cleared by leaving them out.
+ * ⛔ NO CREDENTIAL IS A PROP; `litellmProviders`' layer supplies `Credentials`.
+ */
+import { Resource } from 'alchemy';
+import { Unowned } from 'alchemy/AdoptPolicy';
+import { isResolved } from 'alchemy/Diff';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import * as Predicate from 'effect/Predicate';
+import { refuseTakeover } from '../ownership/adopt.ts';
+import {
+  LitellmKeyAbsentAfterWriteError,
+  LitellmKeyAliasChangedError,
+  LitellmKeyFieldNotAppliedError,
+  LitellmKeyValueNotHonouredError,
+} from './key-errors.ts';
+import {
+  type KeyAttributes,
+  type KeyProps,
+  createBody,
+  differing,
+  updateBody,
+} from './key-form.ts';
+import { callbackSlotsIn } from './key-metadata.ts';
+import {
+  LitellmKeyCallbackMetadataDeclaredError,
+  LitellmKeyCallbackMetadataLiveError,
+} from './key-metadata-errors.ts';
+import { deleteKey, findKey, generateKey, readKeyToken, updateKey } from './key-operations.ts';
+import {
+  echoes,
+  hasKeyValue,
+  refuseDebugLogging,
+  resolveKeyValue,
+  verifyKeyValue,
+} from './key-secret.ts';
+
+export type { KeyAttributes, KeyProps };
+export type { KeyError } from './key-errors.ts';
+
+export interface LiteLLMKey extends Resource<'LiteLLM.Key', KeyProps, KeyAttributes> {}
+
+export const LiteLLMKey = Resource<LiteLLMKey>('LiteLLM.Key', { defaultRemovalPolicy: 'retain' });
+
+export const isLiteLLMKey = (value: unknown): value is LiteLLMKey =>
+  Predicate.hasProperty(value, 'Type') && value.Type === 'LiteLLM.Key';
+
+/** The row with the memo the row cannot carry: what this provider last wrote for `duration`. */
+const remembering = (live: KeyAttributes, output: KeyAttributes | undefined): KeyAttributes => ({
+  ...live,
+  duration: output?.duration ?? null,
+});
+
+/**
+ * What state remembers of `duration` after a write: the declaration when it names one, else what it
+ * remembered (`before`, `undefined` for a key just created). The row carries only `expires`.
+ */
+const remembered = (news: KeyProps, before: KeyAttributes | undefined): string | null =>
+  news.duration !== undefined ? news.duration : (before?.duration ?? null);
+
+/**
+ * The `metadata` refusals that need no write to know (key-metadata.ts): a declaration that names a
+ * callback slot, and — given the live row — a metadata write onto a key that holds one.
+ */
+const refuseMetadata = (news: KeyProps, live: KeyAttributes | undefined) =>
+  Effect.gen(function* () {
+    const declared = callbackSlotsIn(news.metadata);
+    if (declared.length > 0) {
+      return yield* new LitellmKeyCallbackMetadataDeclaredError({
+        keyAlias: news.keyAlias,
+        slots: declared,
+      });
+    }
+    if (
+      live !== undefined &&
+      live.withheld.length > 0 &&
+      differing(live, news).includes('metadata')
+    ) {
+      return yield* new LitellmKeyCallbackMetadataLiveError({
+        keyAlias: news.keyAlias,
+        slots: live.withheld,
+      });
+    }
+  });
+
+/**
+ * Create the key, then prove LiteLLM stored the value it was sent.
+ * ⛔ A PROXY THAT MINTS ITS OWN VALUE INSTEAD leaves a row nobody can authenticate with, reported as
+ *   a success. `/key/generate` echoes the key (`Redacted`, never logged); a different one is deleted
+ *   again and refused. UNVERIFIED that any proxy does this — the 1.103.0 docstring says the value is
+ *   honoured — but a key nobody holds is not a failure to discover later.
+ */
+const createKey = (news: KeyProps) =>
+  Effect.gen(function* () {
+    yield* refuseDebugLogging(news.keyAlias);
+    const secret = yield* resolveKeyValue(news.keyAlias, news.key);
+    const created = yield* generateKey(createBody(news, secret));
+    if (echoes(created.key, secret)) return;
+    const removed = yield* deleteKey(news.keyAlias).pipe(
+      Effect.as(true),
+      Effect.orElseSucceed(() => false),
+    );
+    return yield* new LitellmKeyValueNotHonouredError({ keyAlias: news.keyAlias, removed });
+  });
+
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export const keyHandlers = {
+  read: ({ olds, output }: { olds: KeyProps; output: KeyAttributes | undefined }) =>
+    Effect.gen(function* () {
+      const live = yield* findKey(output?.keyAlias ?? olds.keyAlias);
+      if (live === undefined) return undefined;
+      return output === undefined ? Unowned(live) : remembering(live, output);
+    }),
+
+  diff: ({ news, output }: { news: Input<KeyProps>; output: KeyAttributes | undefined }) =>
+    Effect.gen(function* () {
+      if (!isResolved(news)) return undefined;
+      yield* refuseMetadata(news, output);
+      if (output === undefined) return undefined;
+      if (news.keyAlias !== output.keyAlias) {
+        return yield* new LitellmKeyAliasChangedError({ from: output.keyAlias, to: news.keyAlias });
+      }
+      // beta.79 Provider.ts:274-289 permits effectful diff, and Plan.ts:1503-1527 calls it
+      // even for unchanged props. Refuse an immutable value mismatch before a false noop.
+      if (hasKeyValue(news.key)) {
+        const token = yield* readKeyToken(news.keyAlias);
+        // A dashboard deletion leaves stale output: recreate even without a settings change.
+        if (token === undefined) return { action: 'update' } as const;
+        yield* verifyKeyValue(news.keyAlias, news.key, token);
+      }
+      return differing(output, news).length === 0
+        ? ({ action: 'noop' } as const)
+        : ({ action: 'update' } as const);
+    }),
+
+  reconcile: ({
+    fqn,
+    instanceId,
+    news,
+    output,
+  }: {
+    fqn: string;
+    instanceId: string;
+    news: KeyProps;
+    output: KeyAttributes | undefined;
+  }) =>
+    Effect.gen(function* () {
+      const alias = news.keyAlias;
+      yield* refuseMetadata(news, undefined);
+      const found = yield* findKey(alias);
+      const before = found === undefined ? undefined : remembering(found, output);
+      if (before === undefined) {
+        yield* createKey(news);
+      } else {
+        yield* refuseTakeover({ fqn, instanceId, output }, `LiteLLM.Key ${alias}`);
+        // ⚠️ AN ADOPTED KEY'S DECLARED VALUE IS CHECKED AGAINST THE ROW (key-secret.ts's header):
+        //   only when `key: { fromEnv }` names a variable, only as a sha256 in memory, and nothing
+        //   is written about a mismatch (`/key/update` cannot change a key's value). No `key` declared
+        //   means no extra read: `readKeyToken` is a `/key/list`, and an omitted value is never held.
+        if (hasKeyValue(news.key)) {
+          yield* verifyKeyValue(alias, news.key, (yield* readKeyToken(alias)) ?? null);
+        }
+        yield* refuseMetadata(news, before);
+        if (differing(before, news).length > 0) yield* updateKey(updateBody(news, before));
+      }
+
+      const after = yield* findKey(alias);
+      if (after === undefined)
+        return yield* new LitellmKeyAbsentAfterWriteError({ keyAlias: alias });
+      // ★ THE MEMO IS THE DECLARATION when it names a `duration` (else what state already remembered):
+      //   a write that reached here carried `duration` whenever the expiry differed, so what is left
+      //   to check is the row itself (and whether it HAS an expiry).
+      const settled = { ...after, duration: remembered(news, before) };
+      const left = differing(settled, news);
+      if (left.length > 0) {
+        return yield* new LitellmKeyFieldNotAppliedError({ fields: left, keyAlias: alias });
+      }
+      return settled;
+    }),
+
+  delete: ({ output }: { output: KeyAttributes }) => deleteKey(output.keyAlias),
+
+  /**
+   * ⚠️ ENUMERATES NOTHING, ON PURPOSE. `nuke` walks `list` and deletes what it finds; a proxy's key
+   *   table holds every live credential the estate's services authenticate with, plus dashboard
+   *   session keys nobody declared — none of which this stack made.
+   */
+  list: () => Effect.succeed([]),
+};
+
+export const LiteLLMKeyProvider = () =>
+  Provider.effect(LiteLLMKey, Effect.succeed(LiteLLMKey.Provider.of(keyHandlers)));

package/src/litellm/mcp-server-adopt.test.ts

@@ -0,0 +1,86 @@
+/**
+ * `LiteLLM.MCPServer`: adopting a row that already holds a credential, and removal.
+ *
+ * ★ A CREDENTIAL CANNOT BE READ BACK, so an adopted row has no seal. The declaration is
+ *   authoritative: with the variable set it is written once (and sealed); with it unset the plan
+ *   cannot tell, so nothing is written and nothing is demanded.
+ * ⚠️ The fake hides `credentials` on read, like the real proxy is assumed to (unmeasured).
+ */
+import { afterEach, beforeEach, expect, test } from 'bun:test';
+import * as RemovalPolicy from 'alchemy/RemovalPolicy';
+import * as Effect from 'effect/Effect';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { type FakeMcpLitellm, serverRow, startFakeMcpLitellm } from './fake-mcp-litellm.ts';
+import { fakeStack, writesOf } from './fake-stack.ts';
+import { LiteLLMMCPServer } from './mcp-server.ts';
+import type { McpServerProps } from './mcp-server-types.ts';
+
+const KEY = 'sk-test-master';
+const VARIABLE = 'FAKE_MCP_ADOPT_TOKEN';
+
+const stack = (fake: FakeMcpLitellm) => fakeStack({ apiKey: KEY, baseUrl: FAKE_BASE }, fake.fetch);
+
+const props: McpServerProps = {
+  authType: 'api_key',
+  authValue: { fromEnv: VARIABLE },
+  serverName: 'FAKE_keyed',
+  transport: 'http',
+  url: 'https://keyed.example.com/mcp',
+};
+const held = serverRow({
+  auth_type: 'api_key',
+  server_id: 'FAKE-uuid-9',
+  server_name: 'FAKE_keyed',
+  url: 'https://keyed.example.com/mcp',
+});
+
+beforeEach(() => {
+  process.env[VARIABLE] = 'FAKE-adopt-one';
+});
+afterEach(() => {
+  delete process.env[VARIABLE];
+});
+
+test('adopting with the variable set writes the declared credential once, then is a no-op', async () => {
+  const fake = startFakeMcpLitellm({ masterKey: KEY, seed: [held] });
+  const engine = stack(fake);
+  const declare = Effect.asVoid(LiteLLMMCPServer('Keyed', props));
+  await engine.deploy(declare, { adopt: true });
+  expect(fake.servers()[0]?.['credentials']).toEqual({ auth_value: 'FAKE-adopt-one' });
+  const before = fake.requests().length;
+  expect(await engine.deploy(declare, { adopt: true })).toEqual({ Keyed: 'noop' });
+  expect(writesOf(fake.requests().slice(before))).toEqual([]);
+});
+
+test('adopting with the variable unset writes nothing and demands nothing; a later deploy with it set writes', async () => {
+  const fake = startFakeMcpLitellm({ masterKey: KEY, seed: [held] });
+  const engine = stack(fake);
+  const declare = Effect.asVoid(LiteLLMMCPServer('Keyed', props));
+  delete process.env[VARIABLE];
+  await engine.deploy(declare, { adopt: true });
+  expect(writesOf(fake.requests())).toEqual([]);
+  process.env[VARIABLE] = 'FAKE-adopt-two';
+  expect(await engine.deploy(declare)).toEqual({ Keyed: 'update' });
+  expect(fake.servers()[0]?.['credentials']).toEqual({ auth_value: 'FAKE-adopt-two' });
+});
+
+test('under RemovalPolicy.destroy() a removed declaration deletes the row; the default retains it', async () => {
+  const fake = startFakeMcpLitellm({ masterKey: KEY });
+  const engine = stack(fake);
+  const noCredential: McpServerProps = {
+    authType: 'none',
+    serverName: props.serverName,
+    transport: props.transport,
+    url: props.url,
+  };
+  await engine.deploy(
+    Effect.asVoid(LiteLLMMCPServer('Gone', noCredential).pipe(RemovalPolicy.destroy())),
+  );
+  expect(fake.servers()).toHaveLength(1);
+  expect(await engine.deploy(Effect.void)).toEqual({ Gone: 'delete' });
+  expect(fake.servers()).toEqual([]);
+
+  await engine.deploy(Effect.asVoid(LiteLLMMCPServer('Kept', noCredential)));
+  await engine.deploy(Effect.void);
+  expect(fake.servers()).toHaveLength(1);
+});