@frockbot/plugin-authoring 0.0.0 → 0.1.1

package/src/quota.ts

@@ -0,0 +1,308 @@
+// D7 quotas, as durable per-User configuration in the User Durable Object.
+//
+// "Generation creation rate, artifact size, retained generations ... are
+// bounded by durable per-User quotas; exceeding a quota refuses the operation
+// and records a visible failure." The User's Durable Object is the authority
+// for User-scoped quotas, so the counter and the configured limits live there
+// and the Bot's Durable Object reserves a unit over a narrow RPC before it
+// records an authorship intent.
+//
+// Reservation is idempotent on the authoring `effectId`: a resumed Turn that
+// re-executes the same tool call must not consume a second unit.
+
+export const AUTHORING_QUOTA_CONFIG_KEY = "quota:authoring";
+export const AUTHORING_QUOTA_COUNTER_PREFIX = "quota:generations:";
+export const AUTHORING_QUOTA_RESERVATION_PREFIX = "quota:reservation:";
+
+/** D7 defaults. Durable per-User config overrides them. */
+export const AUTHORING_QUOTA_DEFAULTS_V1: AuthoringQuotaConfigV1 = {
+  schemaVersion: 1,
+  retainedGenerationsPerBot: 50,
+  authoredPerUserPerDay: 100,
+  maxSourceBytes: 256 * 1024,
+};
+
+export interface AuthoringQuotaConfigV1 {
+  schemaVersion: 1;
+  retainedGenerationsPerBot: number;
+  authoredPerUserPerDay: number;
+  maxSourceBytes: number;
+}
+
+export type AuthoringQuotaLimitV1 =
+  "source-bytes" | "retained-generations" | "authored-per-day";
+
+export interface AuthoringQuotaRequestV1 {
+  schemaVersion: 1;
+  userId: string;
+  botId: string;
+  /** The authoring effect this unit is reserved for; reservation is per effect. */
+  effectId: string;
+  /** `yyyy-mm-dd`, resolved by the caller from its own clock. */
+  day: string;
+  sourceBytes: number;
+  retainedGenerations: number;
+}
+
+export type AuthoringQuotaReceiptV1 =
+  | {
+      schemaVersion: 1;
+      status: "reserved";
+      effectId: string;
+      day: string;
+      used: number;
+      limit: number;
+    }
+  | {
+      schemaVersion: 1;
+      status: "refused";
+      effectId: string;
+      day: string;
+      limitName: AuthoringQuotaLimitV1;
+      reason: string;
+      used: number;
+      limit: number;
+    };
+
+export const AUTHORING_QUOTA_DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+export function authoringQuotaCounterKey(day: string): string {
+  if (!AUTHORING_QUOTA_DAY.test(day)) {
+    throw new Error("authoring quota day must be yyyy-mm-dd");
+  }
+  return `${AUTHORING_QUOTA_COUNTER_PREFIX}${day}`;
+}
+
+export function authoringQuotaReservationKey(effectId: string): string {
+  return `${AUTHORING_QUOTA_RESERVATION_PREFIX}${effectId}`;
+}
+
+/** `yyyy-mm-dd` in UTC; the counter key is a calendar day, not a rolling window. */
+export function authoringQuotaDayV1(at: Date): string {
+  return at.toISOString().slice(0, 10);
+}
+
+/** The narrow storage surface this module needs from the User Durable Object. */
+export interface AuthoringQuotaTransaction {
+  get<T>(key: string): Promise<T | undefined>;
+  put(key: string, value: unknown): Promise<void>;
+}
+
+/**
+ * The User Durable Object's storage. `transaction` is required because the
+ * daily counter is a read-modify-write that spans awaits: two reservations
+ * racing at the limit would otherwise both read the same count and both admit.
+ */
+export interface AuthoringQuotaStorage extends AuthoringQuotaTransaction {
+  transaction<T>(
+    callback: (storage: AuthoringQuotaTransaction) => Promise<T>,
+  ): Promise<T>;
+}
+
+export function decodeAuthoringQuotaConfigV1(
+  input: unknown,
+): AuthoringQuotaConfigV1 {
+  if (input === undefined) return { ...AUTHORING_QUOTA_DEFAULTS_V1 };
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("authoring quota configuration is invalid");
+  }
+  const value = input as Record<string, unknown>;
+  const keys = [
+    "schemaVersion",
+    "retainedGenerationsPerBot",
+    "authoredPerUserPerDay",
+    "maxSourceBytes",
+  ];
+  if (
+    value.schemaVersion !== 1 ||
+    Object.keys(value).length !== keys.length ||
+    !keys.every((key) => Object.hasOwn(value, key))
+  ) {
+    throw new Error("authoring quota configuration is invalid");
+  }
+  const bounded = (name: keyof AuthoringQuotaConfigV1, maximum: number) => {
+    const candidate = value[name];
+    if (
+      !Number.isSafeInteger(candidate) ||
+      (candidate as number) < 1 ||
+      (candidate as number) > maximum
+    ) {
+      throw new Error(`authoring quota ${String(name)} is invalid`);
+    }
+    return candidate as number;
+  };
+  return {
+    schemaVersion: 1,
+    retainedGenerationsPerBot: bounded("retainedGenerationsPerBot", 10_000),
+    authoredPerUserPerDay: bounded("authoredPerUserPerDay", 100_000),
+    maxSourceBytes: bounded("maxSourceBytes", 8 * 1024 * 1024),
+  };
+}
+
+function counterValue(input: unknown): number {
+  if (input === undefined) return 0;
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("authoring quota counter is invalid");
+  }
+  const value = (input as { count?: unknown }).count;
+  if (!Number.isSafeInteger(value) || (value as number) < 0) {
+    throw new Error("authoring quota counter is invalid");
+  }
+  return value as number;
+}
+
+function refusal(
+  request: AuthoringQuotaRequestV1,
+  limitName: AuthoringQuotaLimitV1,
+  reason: string,
+  used: number,
+  limit: number,
+): AuthoringQuotaReceiptV1 {
+  return {
+    schemaVersion: 1,
+    status: "refused",
+    effectId: request.effectId,
+    day: request.day,
+    limitName,
+    reason,
+    used,
+    limit,
+  };
+}
+
+/**
+ * Reserves one authored-generation unit for the day, or refuses. Never throws
+ * for a breach: a quota breach is an observable outcome the Bot's tool result
+ * reports and the durable failure record preserves.
+ */
+export async function reserveAuthoringQuotaV1(
+  storage: AuthoringQuotaStorage,
+  request: AuthoringQuotaRequestV1,
+): Promise<AuthoringQuotaReceiptV1> {
+  // One transaction from the reservation lookup to the counter write: the
+  // read-modify-write spans awaits, so two concurrent reservations at the
+  // limit must not both see the same count.
+  return storage.transaction(async (transaction) => {
+    const reservationKey = authoringQuotaReservationKey(request.effectId);
+    const existing =
+      await transaction.get<AuthoringQuotaReceiptV1>(reservationKey);
+    if (existing) return existing;
+
+    const config = decodeAuthoringQuotaConfigV1(
+      await transaction.get<unknown>(AUTHORING_QUOTA_CONFIG_KEY),
+    );
+    const counterKey = authoringQuotaCounterKey(request.day);
+    const used = counterValue(await transaction.get<unknown>(counterKey));
+
+    let receipt: AuthoringQuotaReceiptV1;
+    if (request.sourceBytes > config.maxSourceBytes) {
+      receipt = refusal(
+        request,
+        "source-bytes",
+        `Package source is ${request.sourceBytes} bytes; this User's quota allows ${config.maxSourceBytes}`,
+        request.sourceBytes,
+        config.maxSourceBytes,
+      );
+    } else if (
+      request.retainedGenerations >= config.retainedGenerationsPerBot
+    ) {
+      receipt = refusal(
+        request,
+        "retained-generations",
+        `this Bot retains ${request.retainedGenerations} Composition generations; this User's quota allows ${config.retainedGenerationsPerBot}`,
+        request.retainedGenerations,
+        config.retainedGenerationsPerBot,
+      );
+    } else if (used >= config.authoredPerUserPerDay) {
+      receipt = refusal(
+        request,
+        "authored-per-day",
+        `this User has authored ${used} generations on ${request.day}; the daily quota is ${config.authoredPerUserPerDay}`,
+        used,
+        config.authoredPerUserPerDay,
+      );
+    } else {
+      receipt = {
+        schemaVersion: 1,
+        status: "reserved",
+        effectId: request.effectId,
+        day: request.day,
+        used: used + 1,
+        limit: config.authoredPerUserPerDay,
+      };
+      await transaction.put(counterKey, { day: request.day, count: used + 1 });
+    }
+    // Refusals are recorded too: a replayed effect must get the same answer.
+    await transaction.put(reservationKey, receipt);
+    return receipt;
+  });
+}
+
+export function decodeAuthoringQuotaReceiptV1(
+  input: unknown,
+  label = "authoring quota receipt",
+): AuthoringQuotaReceiptV1 {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`${label} must be an object`);
+  }
+  const value = input as Record<string, unknown>;
+  if (value.schemaVersion !== 1) {
+    throw new Error(`${label}.schemaVersion is unsupported`);
+  }
+  const text = (name: string, maximum: number): string => {
+    const candidate = value[name];
+    if (
+      typeof candidate !== "string" ||
+      candidate.length === 0 ||
+      candidate.length > maximum
+    ) {
+      throw new Error(`${label}.${name} is invalid`);
+    }
+    return candidate;
+  };
+  const integer = (name: string): number => {
+    const candidate = value[name];
+    if (!Number.isSafeInteger(candidate) || (candidate as number) < 0) {
+      throw new Error(`${label}.${name} is invalid`);
+    }
+    return candidate as number;
+  };
+  const effectId = text("effectId", 200);
+  const day = text("day", 10);
+  if (value.status === "reserved") {
+    return {
+      schemaVersion: 1,
+      status: "reserved",
+      effectId,
+      day,
+      used: integer("used"),
+      limit: integer("limit"),
+    };
+  }
+  if (value.status === "refused") {
+    const limitName = value.limitName;
+    if (
+      limitName !== "source-bytes" &&
+      limitName !== "retained-generations" &&
+      limitName !== "authored-per-day"
+    ) {
+      throw new Error(`${label}.limitName is invalid`);
+    }
+    return {
+      schemaVersion: 1,
+      status: "refused",
+      effectId,
+      day,
+      limitName,
+      reason: text("reason", 1_024),
+      used: integer("used"),
+      limit: integer("limit"),
+    };
+  }
+  throw new Error(`${label}.status is invalid`);
+}
+
+/** The narrow RPC the Bot Durable Object calls on the User Durable Object. */
+export interface AuthoringQuotaBinding {
+  reserve(request: AuthoringQuotaRequestV1): Promise<AuthoringQuotaReceiptV1>;
+}

package/src/records.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import {
+  artifactKey,
+  artifactR2KeyV1,
+  authorshipArtifactKey,
+  authorshipIntentKey,
+  classifyAuthoringEffectV1,
+  type AuthoringEffectOutcomeV1,
+  type AuthorshipIntentV1,
+} from "./records.ts";
+
+const INTENT: AuthorshipIntentV1 = {
+  schemaVersion: 1,
+  effectId: "author-0123456789abcdef",
+  botId: "bot-1",
+  sessionId: "user-1:bot-1",
+  runId: "run-1",
+  turnId: "run-1",
+  packageId: "weather-lookup",
+  version: "0.0.1",
+  sourceHash: "a".repeat(64),
+  sourceBytes: 64,
+  recordedAt: "2026-08-31T00:00:00.000Z",
+  status: "recorded",
+};
+
+const BUNDLED: AuthoringEffectOutcomeV1 = {
+  schemaVersion: 1,
+  status: "bundled",
+  effectId: INTENT.effectId,
+  contentHash: "b".repeat(64),
+  version: "0.0.1",
+};
+
+describe("authoring effect recovery", () => {
+  test("no intent means the effect never started", () => {
+    expect(
+      classifyAuthoringEffectV1({ intent: undefined, outcome: undefined }),
+    ).toEqual({ kind: "fresh" });
+  });
+
+  test("an intent with no outcome is unknown, never re-bundled", () => {
+    const classification = classifyAuthoringEffectV1({
+      intent: INTENT,
+      outcome: undefined,
+    });
+    expect(classification.kind).toBe("unknown");
+    expect(
+      classification.kind === "unknown" ? classification.reason : "",
+    ).toContain("will not be bundled again");
+  });
+
+  test("a recorded outcome settles the effect on its content address", () => {
+    expect(
+      classifyAuthoringEffectV1({ intent: INTENT, outcome: BUNDLED }),
+    ).toEqual({ kind: "settled", outcome: BUNDLED });
+  });
+
+  test("a recorded bundler refusal replays as the same refusal", () => {
+    expect(
+      classifyAuthoringEffectV1({
+        intent: INTENT,
+        outcome: {
+          schemaVersion: 1,
+          status: "failed",
+          effectId: INTENT.effectId,
+          failureId: "authoring-failure-1",
+          reason: "the Package bundler rejected this source: bundle-failed",
+        },
+      }),
+    ).toMatchObject({ kind: "failed", failureId: "authoring-failure-1" });
+  });
+
+  test("an outcome with no intent is unknown, not settled", () => {
+    expect(
+      classifyAuthoringEffectV1({ intent: undefined, outcome: BUNDLED }).kind,
+    ).toBe("unknown");
+  });
+
+  test("keys are the plan's records", () => {
+    expect(authorshipIntentKey("author-a")).toBe("authorship:intent:author-a");
+    expect(authorshipArtifactKey("author-a")).toBe(
+      "authorship:artifact:author-a",
+    );
+    expect(artifactKey("b".repeat(64))).toBe(`artifact:${"b".repeat(64)}`);
+    expect(artifactR2KeyV1("b".repeat(64))).toBe(
+      `packages/${"b".repeat(64)}.mjs`,
+    );
+  });
+});

package/src/records.ts

@@ -0,0 +1,172 @@
+// The durable records one authoring effect leaves in the Bot Durable Object,
+// and the classifier that reads them after an eviction.
+//
+// Constitution, Durable effects: "A mutation ... records intent and an effect
+// identifier ... before it runs, so recovery can read its outcome or classify
+// it as unknown without repeating it." Bundling is that mutation. The intent is
+// written first; the artifact record and the effect index are written together
+// afterwards; recovery reads both and never re-bundles on a guess.
+
+export const AUTHORSHIP_INTENT_PREFIX = "authorship:intent:";
+export const AUTHORSHIP_ARTIFACT_PREFIX = "authorship:artifact:";
+export const AUTHORSHIP_FAILURE_PREFIX = "authorship:failure:";
+export const AUTHORSHIP_PACKAGE_PREFIX = "authorship:package:";
+export const ARTIFACT_PREFIX = "artifact:";
+
+export function authorshipIntentKey(effectId: string): string {
+  return `${AUTHORSHIP_INTENT_PREFIX}${effectId}`;
+}
+
+/** effectId → contentHash. Written in the same transaction as `artifact:<hash>`. */
+export function authorshipArtifactKey(effectId: string): string {
+  return `${AUTHORSHIP_ARTIFACT_PREFIX}${effectId}`;
+}
+
+export function authorshipFailureKey(failureId: string): string {
+  return `${AUTHORSHIP_FAILURE_PREFIX}${failureId}`;
+}
+
+export function authorshipPackageKey(packageId: string): string {
+  return `${AUTHORSHIP_PACKAGE_PREFIX}${packageId}`;
+}
+
+export function artifactKey(contentHash: string): string {
+  return `${ARTIFACT_PREFIX}${contentHash}`;
+}
+
+export interface AuthorshipIntentV1 {
+  schemaVersion: 1;
+  effectId: string;
+  botId: string;
+  sessionId: string;
+  runId: string;
+  turnId: string;
+  packageId: string;
+  version: string;
+  /** sha-256 of the source text. The source itself is never durable state. */
+  sourceHash: string;
+  sourceBytes: number;
+  recordedAt: string;
+  status: "recorded";
+}
+
+/** The immutable content record for one Bot-authored artifact. */
+export interface AuthoredArtifactRecordV1 {
+  schemaVersion: 1;
+  contentHash: string;
+  size: number;
+  mediaType: "application/javascript";
+  bundlerVersion: string;
+  effectId: string;
+  r2Key: string;
+  provenance: {
+    kind: "bot";
+    packageId: string;
+    version: string;
+    botId: string;
+    sessionId: string;
+    turnId: string;
+    runId: string;
+    authoredAt: string;
+  };
+  createdAt: string;
+}
+
+/** The latest recorded version of one authored Package identity. */
+export interface AuthoredPackageRecordV1 {
+  schemaVersion: 1;
+  packageId: string;
+  ordinal: number;
+  version: string;
+  contentHash: string;
+  updatedAt: string;
+}
+
+/** A visible durable failure. Quota refusals and unknown effects both land here. */
+export interface AuthoringFailureRecordV1 {
+  schemaVersion: 1;
+  failureId: string;
+  effectId: string;
+  botId: string;
+  packageId: string;
+  runId: string;
+  phase: "quota" | "bundle" | "recovery" | "compose";
+  reason: string;
+  diagnostics: string[];
+  recordedAt: string;
+}
+
+export function artifactR2KeyV1(contentHash: string): string {
+  return `packages/${contentHash}.mjs`;
+}
+
+/**
+ * The durable outcome of one authoring effect, written under
+ * `authorship:artifact:<effectId>` in the same put as `artifact:<contentHash>`.
+ * `generationId` is filled in once the generation has been recorded, so a
+ * replay resolves to the same generation rather than proposing another.
+ */
+export type AuthoringEffectOutcomeV1 =
+  | {
+      schemaVersion: 1;
+      status: "bundled";
+      effectId: string;
+      contentHash: string;
+      version: string;
+      generationId?: string;
+    }
+  | {
+      schemaVersion: 1;
+      status: "failed";
+      effectId: string;
+      failureId: string;
+      reason: string;
+    };
+
+export type AuthoringEffectClassificationV1 =
+  /** No intent recorded: the effect has not started and may run. */
+  | { kind: "fresh" }
+  /** The artifact exists and is addressed by hash: reuse it, never re-bundle. */
+  | {
+      kind: "settled";
+      outcome: Extract<AuthoringEffectOutcomeV1, { status: "bundled" }>;
+    }
+  /** The bundler answered and refused. The same answer is replayed. */
+  | { kind: "failed"; failureId: string; reason: string }
+  /**
+   * Intent exists with no recorded outcome. The bundler may or may not have
+   * run; nothing durable says which. The effect is unknown and is reported,
+   * not retried.
+   */
+  | { kind: "unknown"; reason: string };
+
+/**
+ * Reads one authoring effect's durable trail. Pure, so the eviction window it
+ * exists for is testable without a Durable Object.
+ */
+export function classifyAuthoringEffectV1(input: {
+  intent: AuthorshipIntentV1 | undefined;
+  outcome: AuthoringEffectOutcomeV1 | undefined;
+}): AuthoringEffectClassificationV1 {
+  if (input.outcome) {
+    if (!input.intent) {
+      return {
+        kind: "unknown",
+        reason:
+          "an authoring outcome is recorded for an effect with no recorded intent",
+      };
+    }
+    return input.outcome.status === "bundled"
+      ? { kind: "settled", outcome: input.outcome }
+      : {
+          kind: "failed",
+          failureId: input.outcome.failureId,
+          reason: input.outcome.reason,
+        };
+  }
+  if (!input.intent) return { kind: "fresh" };
+  return {
+    kind: "unknown",
+    reason: `authoring effect "${input.intent.effectId}" recorded its intent but has no durable outcome; it will not be bundled again`,
+  };
+}

package/src/shared.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import {
+  authoredManifestV1,
+  authoredVersionV1,
+  authoringEffectIdV1,
+  decodeAuthorPackageInputV1,
+  sha256HexV1,
+} from "./shared.ts";
+
+const VALID = {
+  packageId: "weather-lookup",
+  displayName: "Weather lookup",
+  tool: {
+    name: "weather_lookup",
+    description: "Looks up the weather",
+    inputSchema: { type: "object", properties: { city: { type: "string" } } },
+  },
+  source: "export const tools = [];\nexport async function execute() {}\n",
+};
+
+describe("decodeAuthorPackageInputV1", () => {
+  test("accepts the exact v1 shape and the optional model Contribution", () => {
+    expect(decodeAuthorPackageInputV1(VALID)).toEqual(VALID);
+    expect(
+      decodeAuthorPackageInputV1({
+        ...VALID,
+        model: { providerId: "ollama-cloud", modelId: "qwen3-coder:480b" },
+      }).model,
+    ).toEqual({ providerId: "ollama-cloud", modelId: "qwen3-coder:480b" });
+  });
+
+  test.each([
+    ["a non-object", 7],
+    ["an unknown field", { ...VALID, activate: true }],
+    ["a missing field", { ...VALID, source: undefined }],
+    ["an upper-case package id", { ...VALID, packageId: "Weather" }],
+    ["a one-character package id", { ...VALID, packageId: "a" }],
+    [
+      "a tool name with a dash",
+      { ...VALID, tool: { ...VALID.tool, name: "a-b" } },
+    ],
+    ["an empty source", { ...VALID, source: "" }],
+    [
+      "a non-object input schema",
+      { ...VALID, tool: { ...VALID.tool, inputSchema: "object" } },
+    ],
+    [
+      "a partial model Contribution",
+      { ...VALID, model: { providerId: "ollama-cloud" } },
+    ],
+  ])("rejects %s", (_label, input) => {
+    expect(() => decodeAuthorPackageInputV1(input)).toThrow();
+  });
+
+  test("rejects source beyond the 256 KB per-Package quota", () => {
+    expect(() =>
+      decodeAuthorPackageInputV1({
+        ...VALID,
+        source: "a".repeat(256 * 1024 + 1),
+      }),
+    ).toThrow();
+  });
+});
+
+describe("authoring identity", () => {
+  test("the effect id is deterministic in the run and the exact source", async () => {
+    const sourceHash = await sha256HexV1(VALID.source);
+    const first = await authoringEffectIdV1({
+      runId: "run-1",
+      packageId: VALID.packageId,
+      sourceHash,
+    });
+    const second = await authoringEffectIdV1({
+      runId: "run-1",
+      packageId: VALID.packageId,
+      sourceHash,
+    });
+    const otherRun = await authoringEffectIdV1({
+      runId: "run-2",
+      packageId: VALID.packageId,
+      sourceHash,
+    });
+    const otherSource = await authoringEffectIdV1({
+      runId: "run-1",
+      packageId: VALID.packageId,
+      sourceHash: await sha256HexV1(`${VALID.source}//`),
+    });
+
+    expect(first).toBe(second);
+    expect(first).not.toBe(otherRun);
+    expect(first).not.toBe(otherSource);
+    expect(first.length).toBeLessThanOrEqual(200);
+  });
+
+  test("versions are appended, never overwritten", () => {
+    expect(authoredVersionV1(1)).toBe("0.0.1");
+    expect(authoredVersionV1(2)).toBe("0.0.2");
+    expect(() => authoredVersionV1(0)).toThrow();
+  });
+
+  test("the synthesized manifest declares only the isolate host", () => {
+    const manifest = authoredManifestV1({
+      packageId: VALID.packageId,
+      displayName: VALID.displayName,
+      version: "0.0.1",
+      tool: VALID.tool,
+      model: { providerId: "ollama-cloud", modelId: "qwen3-coder:480b" },
+    });
+    const contributions = manifest.contributions as Record<
+      string,
+      { host?: string; binding?: string }
+    >;
+    expect(Object.keys(contributions).toSorted()).toEqual(["model", "runtime"]);
+    expect(contributions.runtime?.host).toBe("bot-isolate");
+    expect(contributions.model?.host).toBe("bot-isolate");
+    // A Bot-authored model adapter is a translation layer over a kernel
+    // binding, never a network client.
+    expect(contributions.model?.binding).toBe("capabilities.invokeModel");
+    expect(manifest.permissions).toEqual([]);
+  });
+
+  test("the manifest hash moves when the declared model Contribution moves", () => {
+    const base = authoredManifestV1({
+      packageId: VALID.packageId,
+      displayName: VALID.displayName,
+      version: "0.0.1",
+      tool: VALID.tool,
+    });
+    const withModel = authoredManifestV1({
+      packageId: VALID.packageId,
+      displayName: VALID.displayName,
+      version: "0.0.1",
+      tool: VALID.tool,
+      model: { providerId: "ollama-cloud", modelId: "qwen3-coder:480b" },
+    });
+    expect(JSON.stringify(base)).not.toBe(JSON.stringify(withModel));
+  });
+});