@homeflare/alchemy 0.43.0 → 0.45.0

package/src/litellm/model-params-preserve.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Adopt and a later params write must not clobber `litellm_params` this resource does not own.
+ *
+ * ⚠️ `fillsParamDefaults` models v1.103.0 `updateLiteLLMParams`: the parsed model fills every
+ *   unset field with its pydantic default before the write, a non-`None` default (`false`)
+ *   overwrites the stored value, and JSON `null` is the `None` that keeps the stored value. The
+ *   real PATCH route merges — sent keys land, the rest of the row survives — which is exactly
+ *   what stops the write clobbering keys the declaration does not own. This file pins that.
+ */
+import { expect, test } from 'bun:test';
+import * as Effect from 'effect/Effect';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { type FakeModelLitellm, modelRow, startFakeModelLitellm } from './fake-model-litellm.ts';
+import { fakeStack, writesOf } from './fake-stack.ts';
+import { LiteLLMModel } from './model.ts';
+import type { ModelProps } from './model-types.ts';
+
+type Row = Record<string, unknown>;
+
+const KEY = 'sk-test-master';
+
+const stack = (fake: FakeModelLitellm) =>
+  fakeStack({ apiKey: KEY, baseUrl: FAKE_BASE }, fake.fetch);
+
+const declare = (props: ModelProps, name = 'Grok') =>
+  Effect.gen(function* () {
+    yield* LiteLLMModel(name, props);
+  });
+
+const liveParams = {
+  model: 'xai/grok-4.7',
+  use_in_pass_through: true,
+  use_xai_oauth: true,
+  'FAKE-extra-param': 'kept',
+};
+
+test('adopting a matching row stamps the seal locally and leaves unmanaged params', async () => {
+  const fake = startFakeModelLitellm({
+    fillsParamDefaults: true,
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: liveParams,
+        model_info: { access_groups: [], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const adopted: ModelProps = { model: 'xai/grok-4.7', modelName: 'grok' };
+  const engine = stack(fake);
+  expect(await engine.deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'adopted' });
+  expect(writesOf(fake.requests())).not.toContain('PATCH /model/FAKE-live-id/update');
+  expect(fake.models()[0]?.['litellm_params']).toEqual(liveParams);
+  expect(await engine.deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'noop' });
+});
+
+test('adopting a matching row still converges a DECLARED credential, flags intact', async () => {
+  const fake = startFakeModelLitellm({
+    fillsParamDefaults: true,
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: {
+          model: 'xai/grok-4.7',
+          api_key: 'os.environ/FAKE_OLD_KEY',
+          use_in_pass_through: true,
+        },
+        model_info: { access_groups: [], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  // api_key is never on the read, so the row looks like a perfect match: only the declared
+  // credential reference says otherwise, and only a write can converge it (model-form.ts).
+  const adopted: ModelProps = {
+    apiKey: { fromEnv: 'FAKE_NEW_KEY' },
+    model: 'xai/grok-4.7',
+    modelName: 'grok',
+  };
+  const engine = stack(fake);
+  expect(await engine.deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'adopted' });
+  expect(writesOf(fake.requests())).toContain('PATCH /model/FAKE-live-id/update');
+  expect(fake.models()[0]?.['litellm_params']).toMatchObject({
+    api_key: 'os.environ/FAKE_NEW_KEY',
+    model: 'xai/grok-4.7',
+    use_in_pass_through: true,
+  });
+  expect(await engine.deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'noop' });
+});
+
+test('a real params write sends null for the non-None defaults and keeps extra keys', async () => {
+  const fake = startFakeModelLitellm({
+    fillsParamDefaults: true,
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: liveParams,
+        model_info: { access_groups: [], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const adopted: ModelProps = { model: 'xai/grok-4.6', modelName: 'grok' };
+  expect(await stack(fake).deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'adopted' });
+  const patched = fake.bodies().find((body) => body['litellm_params'] !== undefined);
+  const sent = patched?.['litellm_params'] as Row;
+  expect(sent['model']).toBe('xai/grok-4.6');
+  expect(sent['use_in_pass_through']).toBeNull();
+  expect(sent['use_litellm_proxy']).toBeNull();
+  expect(sent['use_xai_oauth']).toBeNull();
+  expect(sent['allow_client_keepalive_override']).toBeNull();
+  expect(sent['merge_reasoning_content_in_choices']).toBeNull();
+  expect(fake.models()[0]?.['litellm_params']).toMatchObject({
+    'FAKE-extra-param': 'kept',
+    model: 'xai/grok-4.6',
+    use_in_pass_through: true,
+    use_xai_oauth: true,
+  });
+});

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

@@ -0,0 +1,57 @@
+/**
+ * A deploy that dies after `POST /model/new` and before the read-back commits attributes.
+ * The next plan resumes the same generation (`creating` or `replacing`, no attributes).
+ *
+ * ★ Through Alchemy's real Plan and Apply. `noRetry` so the injected 500 is the failure, not a
+ *   backoff that then succeeds. Every value is `FAKE-*`.
+ */
+import { expect, test } from 'bun:test';
+import * as Effect from 'effect/Effect';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { type FakeModelLitellm, startFakeModelLitellm } from './fake-model-litellm.ts';
+import { fakeStack } from './fake-stack.ts';
+import { LiteLLMModel } from './model.ts';
+import type { ModelProps } from './model-types.ts';
+
+const KEY = 'sk-test-master';
+const stack = (fake: FakeModelLitellm) =>
+  fakeStack({ apiKey: KEY, baseUrl: FAKE_BASE }, fake.fetch, 'ModelStack', { noRetry: true });
+const declare = (props: ModelProps) =>
+  Effect.gen(function* () {
+    yield* LiteLLMModel('Grok', props);
+  });
+
+const rowId = (row: Record<string, unknown>): string =>
+  String((row['model_info'] as Record<string, unknown>)['id']);
+
+test('an unpinned create interrupted after POST resumes on the next deploy', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  const engine = stack(fake);
+  const props: ModelProps = { model: 'xai/grok-4.7', modelName: 'grok' };
+  fake.failNextReadBacks(1);
+  await expect(engine.deploy(declare(props))).rejects.toThrow(/injected read-back failure/);
+  expect(fake.models()).toHaveLength(1);
+  // The recovery read's instance id is the creating row's, so the physical name matches and the
+  // row is ours. No --adopt.
+  expect(await engine.deploy(declare(props))).toEqual({ Grok: 'create' });
+  expect(await engine.deploy(declare(props))).toEqual({ Grok: 'noop' });
+});
+
+test('a declared-id replace whose read-back 500s resumes with --adopt', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  const engine = stack(fake);
+  const at = (id: string): ModelProps => ({ id, model: 'xai/grok-4.7', modelName: 'grok' });
+  expect(await engine.deploy(declare(at('FAKE-id-a')))).toEqual({ Grok: 'create' });
+  fake.failNextReadBacks(1);
+  await expect(engine.deploy(declare(at('FAKE-id-b')))).rejects.toThrow(
+    /injected read-back failure/,
+  );
+  expect(fake.models().map(rowId)).toContain('FAKE-id-b');
+  // The row is this stack's own, posted before the read-back died. Without --adopt the resume
+  // still refuses; with it, the unfinished generation may take the row it created.
+  await expect(engine.deploy(declare(at('FAKE-id-b')))).rejects.toThrow(/--adopt/);
+  expect(await engine.deploy(declare(at('FAKE-id-b')), { adopt: true })).toEqual({
+    Grok: 'replace',
+  });
+  expect(await engine.deploy(declare(at('FAKE-id-b')), { adopt: true })).toEqual({ Grok: 'noop' });
+});

package/src/litellm/model-types.ts

@@ -0,0 +1,112 @@
+/**
+ * What a `LiteLLM.Model` declares (props) and what is remembered about it (attributes).
+ *
+ * ⛔ NO CREDENTIAL VALUE IS A PROP OR AN ATTRIBUTE (S25). Alchemy persists props AND attributes
+ *   unencrypted (`StateEncoding.ts` writes a `Redacted` value's inner string beside its tag,
+ *   measured on alchemy 2.0.0-beta.79), so `apiKey` is `{ fromEnv: 'NAME' }`: the NAME is stored,
+ *   the value lives only in the deploying process and on the wire, and it is sent in LiteLLM's own
+ *   reference form `os.environ/NAME` — so the PROXY reads it from ITS environment at call time and
+ *   the proxy's own DB row never carries a literal either. A `Redacted` prop would still land in
+ *   state as plaintext (mcp-server-types.ts's reasoning, same store).
+ * ⛔ THE LIVE ROW'S `litellm_params` ARE NEVER MIRRORED INTO ATTRIBUTES. At v1.103.0 the read
+ *   answers the stored params DECRYPTED but STRIPS `api_key` (measured on a live 1.103.0 proxy),
+ *   and anything mirrored would land in state as plaintext — Alchemy persists attributes
+ *   unencrypted. So a read compares only the visible fields the proxy returns, and this
+ *   resource's own attributes carry a DIGEST of the DECLARED values (`paramsSeal`), never the
+ *   values: that is how a plan notices a declared credential moved when the read cannot show it.
+ * ⚠️ NOT MODELLED, on purpose: the rest of `litellm_params` (rpm/tpm, timeouts, fallbacks,
+ *   wildcard routing params, `mock_response`, vertex/aws credential blobs, …), cost fields on
+ *   `model_info` beyond what the read returns, `teams`, and the config-file-only rows
+ *   (`db_model: false`) — a reconcile that finds one REFUSES it (model-errors.ts): the DB
+ *   API cannot manage what the proxy serves from its config file.
+ */
+import type { FromEnv } from '../secrets/write-only.ts';
+
+/**
+ * The LiteLLM-SDK path of the deployment: a provider prefix, then the upstream model, such as
+ * `xai/grok-4.7` or `cloudflare/@cf/meta/llama-3.1-8b-instruct`. Required: LiteLLM needs it to
+ * pick the provider handler, and an unprefixed name is ambiguous.
+ */
+export type ModelLiteLLMPath = string;
+
+export interface ModelProps {
+  /**
+   * The group name callers use (`/chat/completions` `model: …`), one group = one or more
+   * deployments. This is also how an existing row is ADOPTED: the live row whose `model_name`
+   * equals it. ⛔ Renaming a group changes nothing upstream — LiteLLM keys deployments by id —
+   * so a changed `modelName` with no pinned `id` is a REPLACE: the new group gets a fresh id, and
+   * the old row survives under the default `RemovalPolicy.retain()` (opt in to `destroy()` to
+   * delete it). A pinned `id` is that row: the same deployment is renamed in place
+   * (`patchBody` sends `model_name`), and keys routing to the old name miss.
+   */
+  readonly modelName: string;
+  /**
+   * Pins the live row (adopts by id) or chooses the id a create asks for. Without it, a live row
+   * is found by `modelName` and a new one gets a deterministic physical name. A group name is
+   * shared by several deployments on a live proxy: one id selects exactly one.
+   */
+  readonly id?: string;
+  /** The LiteLLM-SDK path, provider prefix included (`xai/grok-4.7`, `cloudflare/@cf/...`). */
+  readonly model: string;
+  /**
+   * The upstream base URL, when the deployment needs one. ⛔ 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 `apiKey` instead.
+   */
+  readonly apiBase?: string;
+  /**
+   * The upstream credential, by the NAME of the environment variable that holds it — sent to the
+   * proxy as LiteLLM's own reference form `os.environ/NAME`, never a literal value. Omitted
+   * leaves the live credential exactly as the proxy holds it (an adopted row is never blanked).
+   */
+  readonly apiKey?: FromEnv;
+  /** The deployment's capabilities, `mode` in LiteLLM's model_info — `chat`, `embedding`, …. */
+  readonly mode?: string;
+  /** The upstream model this one masquerades as, for cost/prompt mapping. */
+  readonly baseModel?: string;
+  /** Access groups this deployment belongs to. Always compared (as a set), default empty. */
+  readonly accessGroups?: readonly string[];
+}
+
+export interface ModelAttributes {
+  readonly id: string;
+  readonly modelName: string;
+  /** Whether the row is served from the database (`model_info.db_model`); false = config-file row. */
+  readonly dbModel: boolean;
+  /** The provider-prefixed path as the live row carries it (null when the read omits it). */
+  readonly model: string | null;
+  readonly mode: string | null;
+  readonly baseModel: string | null;
+  readonly accessGroups: readonly string[];
+  /**
+   * Digest of the DECLARED params this write would send (`scrypt:<salt>:<digest>`), or `''`.
+   * ⛔ Never the values, never a digest of the LIVE row. This is how a plan notices that the
+   * environment variable behind `apiKey` rotated: the read strips `api_key`, so the seal is the
+   * only signal a declared credential moved (model-form.ts's `declaredDigest`).
+   */
+  readonly paramsSeal: string;
+}
+
+/** Whether a value is not a string with something in it. Takes `unknown`: a declaration can say anything. */
+export const isBlank = (value: unknown): boolean =>
+  typeof value !== 'string' || value.trim() === '';
+
+export const MODES: readonly string[] = [
+  'chat',
+  'completion',
+  'embedding',
+  'audio_transcription',
+  'audio_speech',
+  'image_generation',
+  'image_editing',
+  'moderation',
+  'rerank',
+  'search',
+  'realtime',
+  'batch',
+  'video',
+  'ocr',
+];
+
+/** Whether `model` carries a provider prefix, LiteLLM's `litellm.utils.get_llm_provider` rule. */
+export const hasProviderPrefix = (model: string): boolean => /^[a-z0-9_-]+\//i.test(model);

package/src/litellm/model.test.ts

@@ -0,0 +1,222 @@
+/**
+ * `LiteLLM.Model` through Alchemy's real Plan and Apply over the fake proxy
+ * (`fake-model-litellm.ts`): create, no-op, adopt and its stamping write, pinning, rename, drift.
+ *
+ * ★ EVERY VALUE IS `FAKE-*`. No environment variable is set anywhere: the resource sends
+ *   LiteLLM's own reference form and never reads `process.env` (model-credential.ts), so there is
+ *   no value to set and no value to leak — the test asserts exactly that.
+ * ⚠️ WHAT THE FAKE MODELS IS ITS OWN CHOICE, NOT A MEASUREMENT OF LITELLM 1.103.0 (see the fake).
+ *   A test that leans on one of those choices says so.
+ */
+import { expect, test } from 'bun:test';
+import * as Effect from 'effect/Effect';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { type FakeModelLitellm, modelRow, startFakeModelLitellm } from './fake-model-litellm.ts';
+import { fakeStack, writesOf } from './fake-stack.ts';
+import { LiteLLMModel } from './model.ts';
+import type { ModelProps } from './model-types.ts';
+
+type Row = Record<string, unknown>;
+
+const KEY = 'sk-test-master';
+const stack = (fake: FakeModelLitellm) =>
+  fakeStack({ apiKey: KEY, baseUrl: FAKE_BASE }, fake.fetch);
+const declare = (props: ModelProps, name = 'Grok') =>
+  Effect.gen(function* () {
+    yield* LiteLLMModel(name, props);
+  });
+
+const grok: ModelProps = {
+  apiKey: { fromEnv: 'FAKE_XAI_KEY' },
+  model: 'xai/grok-4.7',
+  modelName: 'grok',
+};
+
+test('a first create still reaches POST /model/new when the missing-id read is a 400', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  expect(await stack(fake).deploy(declare(grok))).toEqual({ Grok: 'create' });
+  expect(writesOf(fake.requests())).toEqual(['POST /model/new']);
+  expect(fake.models()).toHaveLength(1);
+});
+
+test('creates a deployment that carries the reference credential, never a value', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  expect(await stack(fake).deploy(declare(grok))).toEqual({ Grok: 'create' });
+  expect(fake.bodies()[0]).toMatchObject({
+    litellm_params: { api_key: 'os.environ/FAKE_XAI_KEY', model: 'xai/grok-4.7' },
+    model_info: { access_groups: [] },
+    model_name: 'grok',
+  });
+  // ★ a deterministic physical name, not a proxy-issued uuid
+  expect(String((fake.models()[0]?.['model_info'] as Row | undefined)?.['id'])).toMatch(
+    /^[a-z0-9-]+$/,
+  );
+});
+
+test('a second deploy of the same declaration writes nothing', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  const same = stack(fake);
+  await same.deploy(declare(grok));
+  const before = fake.requests().length;
+  expect(await same.deploy(declare(grok))).toEqual({ Grok: 'noop' });
+  expect(writesOf(fake.requests().slice(before))).toEqual([]);
+});
+
+test('a different environment NAME moves the reference; the value is never read', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  const same = stack(fake);
+  await same.deploy(declare(grok));
+  const moved = { ...grok, apiKey: { fromEnv: 'FAKE_XAI_KEY_TWO' } };
+  expect(await same.deploy(declare(moved))).toEqual({ Grok: 'update' });
+  expect(fake.models()[0]?.['litellm_params']).toMatchObject({
+    api_key: 'os.environ/FAKE_XAI_KEY_TWO',
+  });
+  expect(await same.deploy(declare(moved))).toEqual({ Grok: 'noop' });
+});
+
+test('removing a declared api_base leaves the live row its own base', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  const same = stack(fake);
+  const withBase = { ...grok, apiBase: 'https://api.xai.example.com' };
+  await same.deploy(declare(withBase));
+  // ★ the read cannot see api_base (it is never copied, model-form.ts), so it is the SEAL that
+  //   notices the declaration changed — and the update deliberately sends no api_base.
+  expect(await same.deploy(declare(grok))).toEqual({ Grok: 'update' });
+  expect(fake.bodies().at(-1)?.['litellm_params']).toMatchObject({
+    api_key: 'os.environ/FAKE_XAI_KEY',
+    model: 'xai/grok-4.7',
+  });
+  expect(fake.bodies().at(-1)?.['litellm_params']).not.toHaveProperty('api_base');
+  expect(fake.models()[0]?.['litellm_params']).toMatchObject({
+    api_base: 'https://api.xai.example.com',
+  });
+  expect(await same.deploy(declare(grok))).toEqual({ Grok: 'noop' });
+});
+
+test('a live row is Unowned: refused without --adopt, adopted with no write when nothing differs', async () => {
+  const fake = startFakeModelLitellm({
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: { model: 'xai/grok-4.7' },
+        model_info: { access_groups: ['FAKE-team'], id: 'FAKE-live-id', mode: 'chat' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const adopted: ModelProps = {
+    accessGroups: ['FAKE-team'],
+    model: 'xai/grok-4.7',
+    modelName: 'grok',
+  };
+  const engine = stack(fake);
+  await expect(engine.deploy(declare(adopted))).rejects.toThrow();
+  expect(writesOf(fake.requests())).toEqual([]);
+  expect(await engine.deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'adopted' });
+  // ★ A matching row records paramsSeal locally. The read strips `api_key`, so a same-shaped
+  //   row could carry a DIFFERENT stored reference — but nothing was declared that manages an
+  //   invisible param, and nothing else drifted, so no PATCH fires (model.ts).
+  expect(writesOf(fake.requests())).toEqual([]);
+  expect(fake.models()[0]?.['model_info'] as Row | undefined).toMatchObject({ mode: 'chat' });
+  expect(await engine.deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'noop' });
+});
+
+test('clearing groups reaches the PATCH route, the only write model_info supports', async () => {
+  // POST /model/update is never sent: v1.103.0 update_model rebuilds litellm_params and does not
+  // write model_info, so a fake that matched that would leave access_groups in place, and the
+  // read-back must not pass.
+  const fake = startFakeModelLitellm({
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: { model: 'xai/grok-4.7' },
+        model_info: { access_groups: ['FAKE-team'], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const adopted: ModelProps = { model: 'xai/grok-4.7', modelName: 'grok' };
+  expect(await stack(fake).deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'adopted' });
+  const id = String((fake.models()[0]?.['model_info'] as Row | undefined)?.['id']);
+  expect(writesOf(fake.requests())).toContain(`PATCH /model/${id}/update`);
+  expect(fake.models()[0]?.['model_info'] as Row | undefined).toMatchObject({ access_groups: [] });
+});
+
+test('adopting a row whose groups the declaration omits clears them', async () => {
+  const fake = startFakeModelLitellm({
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: { model: 'xai/grok-4.7' },
+        model_info: { access_groups: ['FAKE-team'], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const adopted: ModelProps = { model: 'xai/grok-4.7', modelName: 'grok' };
+  expect(await stack(fake).deploy(declare(adopted), { adopt: true })).toEqual({ Grok: 'adopted' });
+  // ★ access_groups is always managed with a default empty set (model-types.ts)
+  expect(fake.models()[0]?.['model_info'] as Row | undefined).toMatchObject({ access_groups: [] });
+});
+
+test('a proxy that drops an edit it cannot apply fails the deploy instead of claiming success', async () => {
+  // ⚠️ the fake's own model of a truthiness check on the update route — unmeasured at 1.103.0
+  const fake = startFakeModelLitellm({
+    editIgnoresFalsy: true,
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: { model: 'xai/grok-4.7' },
+        model_info: { access_groups: ['FAKE-team'], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const adopted: ModelProps = { model: 'xai/grok-4.7', modelName: 'grok' };
+  await expect(stack(fake).deploy(declare(adopted), { adopt: true })).rejects.toThrow();
+});
+
+test('the read strips api_key; the seal, not the read, proves convergence', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  const same = stack(fake);
+  await same.deploy(declare(grok));
+  // ★ measured at v1.103.0: the read answers params decrypted but strips `api_key` (the fake
+  //   models exactly that), while the stored row keeps the reference — the wire, not the table.
+  const read = (await (
+    await fake.fetch(`${FAKE_BASE}/model/info`, {
+      headers: { authorization: `Bearer ${KEY}` },
+    })
+  ).json()) as { data: readonly Row[] };
+  expect(read.data[0]?.['litellm_params']).toEqual({ model: 'xai/grok-4.7' });
+  expect(fake.models()[0]?.['litellm_params']).toMatchObject({
+    api_key: 'os.environ/FAKE_XAI_KEY',
+  });
+  // The read can never carry the credential, so a matching seal is what makes this a noop.
+  const before = fake.requests().length;
+  expect(await same.deploy(declare(grok))).toEqual({ Grok: 'noop' });
+  expect(writesOf(fake.requests().slice(before))).toEqual([]);
+});
+
+test('a row the list omits is still adopted through the by-id read', async () => {
+  const fake = startFakeModelLitellm({
+    listOmits: ['FAKE-live-id'],
+    masterKey: KEY,
+    seed: [
+      modelRow({
+        litellm_params: { model: 'xai/grok-4.7' },
+        model_info: { access_groups: [], id: 'FAKE-live-id' },
+        model_name: 'grok',
+      }),
+    ],
+  });
+  const pinned: ModelProps = { ...grok, id: 'FAKE-live-id' };
+  expect(await stack(fake).deploy(declare(pinned), { adopt: true })).toEqual({ Grok: 'adopted' });
+});
+
+test('a declaration carrying a credential value is refused before a single request', async () => {
+  const fake = startFakeModelLitellm({ masterKey: KEY });
+  await expect(
+    stack(fake).deploy(declare({ ...grok, apiKey: 'FAKE-literal-value' as never })),
+  ).rejects.toThrow();
+  expect(fake.requests()).toEqual([]);
+});