create-windy 0.5.1 → 0.6.0

package/template/packages/server-sdk/src/ai-runtime-readiness-digest.ts

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto";
+import type {
+  AiRuntimeOfferV1,
+  AiRuntimeOffersDigestV1,
+} from "./ai-runtime-readiness.js";
+import { AI_RUNTIME_MAX_OFFERS_V1 } from "./ai-runtime-readiness.js";
+import { captureAiRuntimeInputV1 } from "./ai-runtime-readiness-capture.js";
+import { canonicalizeAiRuntimeOfferLimitsV1 } from "./ai-runtime-readiness-limits.js";
+import { parseAiRuntimeOffersV1 } from "./ai-runtime-readiness-validation-values.js";
+
+/**
+ * 固定 offers 的语义内容；数组型集合和 offer 顺序不影响摘要。
+ * Runtime、Registry 和 Host 必须复用此函数，不能各自发明 canonicalization。
+ * 输入必须满足公开 V1 边界；否则在 canonicalization 前抛出固定 TypeError。
+ */
+export function computeAiRuntimeOffersDigestV1(
+  offers: unknown,
+): AiRuntimeOffersDigestV1 {
+  const captured = captureAiRuntimeInputV1(offers, AI_RUNTIME_MAX_OFFERS_V1);
+  const parsed = captured.ok ? parseAiRuntimeOffersV1(captured.value) : null;
+  if (!parsed) throw new TypeError("AI Runtime offers contract invalid");
+  return digestCanonicalOffers(parsed);
+}
+
+function digestCanonicalOffers(
+  offers: readonly AiRuntimeOfferV1[],
+): AiRuntimeOffersDigestV1 {
+  const canonical = offers
+    .map((offer) => ({
+      variant: offer.variant,
+      capabilities: sorted(offer.capabilities),
+      inputModalities: sorted(offer.inputModalities),
+      outputModalities: sorted(offer.outputModalities),
+      limits: canonicalizeAiRuntimeOfferLimitsV1(offer.limits),
+    }))
+    .sort(({ variant: left }, { variant: right }) => compare(left, right));
+  const hash = createHash("sha256")
+    .update(JSON.stringify(canonical))
+    .digest("hex");
+  return `sha256:${hash}`;
+}
+
+function sorted<T extends string>(values: readonly T[]): readonly T[] {
+  return [...values].sort(compare);
+}
+
+function compare(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-identity.ts

@@ -0,0 +1,16 @@
+export const AI_RUNTIME_DEPLOYMENT_IDENTITY_PREFIX_V1 =
+  "windy-deployment-v1_" as const;
+
+export type AiRuntimeDeploymentIdentityV1 =
+  `${typeof AI_RUNTIME_DEPLOYMENT_IDENTITY_PREFIX_V1}${string}`;
+
+const deploymentIdentityPattern =
+  /^windy-deployment-v1_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+export function parseAiRuntimeDeploymentIdentityV1(
+  value: unknown,
+): AiRuntimeDeploymentIdentityV1 | null {
+  return typeof value === "string" && deploymentIdentityPattern.test(value)
+    ? (value as AiRuntimeDeploymentIdentityV1)
+    : null;
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-keys.ts

@@ -0,0 +1,23 @@
+const stableKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+
+export function parseAiContractStableKeyV1(value: unknown): string | null {
+  return typeof value === "string" && stableKeyPattern.test(value)
+    ? value
+    : null;
+}
+
+export function validAiContractStableKeyV1(value: unknown): value is string {
+  return typeof value === "string" && stableKeyPattern.test(value);
+}
+
+export function validAiContractStableKeyListV1(
+  values: unknown,
+  requireNonEmpty: boolean,
+): values is readonly string[] {
+  return (
+    Array.isArray(values) &&
+    (!requireNonEmpty || values.length > 0) &&
+    values.every(validAiContractStableKeyV1) &&
+    new Set(values).size === values.length
+  );
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-limits.ts

@@ -0,0 +1,141 @@
+import type {
+  AiOperationRequiredLimitsV1,
+  AiOperationRequiredResourcesV1,
+  AiRuntimeOfferLimitsV1,
+  AiRuntimeOfferV1,
+} from "./ai-runtime-readiness.js";
+import {
+  isAiRuntimeRecordV1,
+  parseAiRuntimeNonNegativeIntegerV1,
+  parseAiRuntimePositiveIntegerV1,
+} from "./ai-runtime-readiness-values.js";
+
+interface OfferLimitRule {
+  readonly operationLimit: boolean;
+  readonly requiredInOffer: boolean;
+  readonly parse: (value: unknown) => number | null;
+}
+
+const offerLimitRules = {
+  maxDurationSeconds: positiveOperationLimit(true),
+  maxInputBytes: positiveOperationLimit(true),
+  maxOutputBytes: positiveOperationLimit(true),
+  maxUnits: positiveOperationLimit(false),
+  maxMediaDurationSeconds: positiveOperationLimit(false),
+  maxArtifacts: positiveOperationLimit(false),
+  maxPixelsPerArtifact: positiveOperationLimit(false),
+  maxConcurrentRuns: {
+    operationLimit: false,
+    requiredInOffer: true,
+    parse: parseAiRuntimePositiveIntegerV1,
+  },
+  maxQueueDepth: {
+    operationLimit: false,
+    requiredInOffer: true,
+    parse: parseAiRuntimeNonNegativeIntegerV1,
+  },
+} as const satisfies {
+  readonly [Key in keyof AiRuntimeOfferLimitsV1]-?: OfferLimitRule;
+};
+
+const orderedOfferLimitKeys = Object.keys(
+  offerLimitRules,
+) as readonly (keyof AiRuntimeOfferLimitsV1)[];
+
+const operationLimitKeys = orderedOfferLimitKeys.filter(
+  (key) => offerLimitRules[key].operationLimit,
+) as readonly (keyof AiOperationRequiredLimitsV1)[];
+
+export function parseAiRuntimeOfferLimitsV1(
+  raw: unknown,
+): AiRuntimeOfferLimitsV1 | null {
+  if (!isAiRuntimeRecordV1(raw)) return null;
+  const parsed: Record<string, number> = {};
+  for (const key of orderedOfferLimitKeys) {
+    const rule = offerLimitRules[key];
+    const rawValue = raw[key];
+    if (rawValue === undefined && !rule.requiredInOffer) continue;
+    const value = rule.parse(rawValue);
+    if (value === null) return null;
+    parsed[key] = value;
+  }
+  return parsed as unknown as AiRuntimeOfferLimitsV1;
+}
+
+export function canonicalizeAiRuntimeOfferLimitsV1(
+  limits: AiRuntimeOfferLimitsV1,
+): Readonly<Record<string, number>> {
+  const canonical: Record<string, number> = {};
+  for (const key of orderedOfferLimitKeys) {
+    const value = limits[key];
+    if (value !== undefined) canonical[key] = value;
+  }
+  return canonical;
+}
+
+export function supportsAiOperationLimitsV1(
+  offer: AiRuntimeOfferV1,
+  required: AiOperationRequiredLimitsV1,
+): boolean {
+  return operationLimitKeys.every((key) => {
+    const expected = required[key];
+    return expected === undefined || (offer.limits[key] ?? -1) >= expected;
+  });
+}
+
+export function findAiOperationLimitMismatchV1(
+  offers: readonly AiRuntimeOfferV1[],
+  required: AiOperationRequiredLimitsV1,
+): { key: string; required: number; available: number } {
+  for (const key of operationLimitKeys) {
+    const expected = required[key];
+    if (expected === undefined) continue;
+    const available = Math.max(
+      ...offers.map(({ limits }) => limits[key] ?? -1),
+    );
+    if (available < expected) return { key, required: expected, available };
+  }
+  return { key: "combined", required: 1, available: 0 };
+}
+
+export function supportsAiOperationResourcesV1(
+  offer: AiRuntimeOfferV1,
+  required: AiOperationRequiredResourcesV1,
+): boolean {
+  return (
+    offer.limits.maxConcurrentRuns >= required.minConcurrentRuns &&
+    offer.limits.maxQueueDepth >= required.minQueueDepth
+  );
+}
+
+export function validAiOperationLimitsV1(
+  limits: unknown,
+): limits is AiOperationRequiredLimitsV1 {
+  if (!isAiRuntimeRecordV1(limits)) return false;
+  return operationLimitKeys.every((key) => {
+    const rule = offerLimitRules[key];
+    const value = limits[key];
+    return (
+      (value === undefined && !rule.requiredInOffer) ||
+      rule.parse(value) !== null
+    );
+  });
+}
+
+export function validAiOperationResourcesV1(
+  resources: unknown,
+): resources is AiOperationRequiredResourcesV1 {
+  return (
+    isAiRuntimeRecordV1(resources) &&
+    parseAiRuntimePositiveIntegerV1(resources.minConcurrentRuns) !== null &&
+    parseAiRuntimeNonNegativeIntegerV1(resources.minQueueDepth) !== null
+  );
+}
+
+function positiveOperationLimit(requiredInOffer: boolean): OfferLimitRule {
+  return {
+    operationLimit: true,
+    requiredInOffer,
+    parse: parseAiRuntimePositiveIntegerV1,
+  };
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-projection.ts

@@ -0,0 +1,326 @@
+import {
+  AI_RUNTIME_MAX_PROBE_TTL_SECONDS,
+  AI_RUNTIME_READINESS_SCHEMA_VERSION,
+  type AiOperationReadinessRequirementV1,
+  type AiReadinessReasonCodeV1,
+  type AiReadinessReasonV1,
+  type AiRuntimeDeploymentV1,
+  type AiRuntimeOfferV1,
+  type ModuleAiOperationReadinessV1,
+} from "./ai-runtime-readiness.js";
+import { computeAiRuntimeOffersDigestV1 } from "./ai-runtime-readiness-digest.js";
+import {
+  findAiOperationLimitMismatchV1,
+  supportsAiOperationLimitsV1,
+  supportsAiOperationResourcesV1,
+} from "./ai-runtime-readiness-limits.js";
+import {
+  safeAiOperationIdentityV1,
+  validAiOperationReadinessRequirementV1,
+} from "./ai-runtime-readiness-requirement.js";
+import { validCanonicalAiTimestampV1 } from "./ai-runtime-readiness-time.js";
+import { parseAiRuntimeReadinessV1 } from "./ai-runtime-readiness-validation.js";
+import {
+  acceptsTrustedRuntimeDegradationV1,
+  type AiRuntimeTrustedFullAttestationV1,
+} from "./ai-runtime-readiness-trust.js";
+
+export interface ProjectAiOperationReadinessOptionsV1 {
+  /** 测试或缓存调用可注入当前时间；省略时使用调用时 UTC。 */
+  readonly now?: string;
+  /** 只接受 Host 在先前完整匹配 expected deployment 后保存的独立证明。 */
+  readonly trustedFullAttestation?: AiRuntimeTrustedFullAttestationV1;
+}
+
+/**
+ * 把一个 deployment 的不受信任 readiness snapshot 收窄为 Operation 能力。
+ * 任何无法证明的条件都作为结构化 unavailable 返回，不抛远端错误。
+ */
+export function projectAiOperationReadinessV1(
+  requirement: AiOperationReadinessRequirementV1,
+  snapshot: unknown,
+  options: ProjectAiOperationReadinessOptionsV1 = {},
+): ModuleAiOperationReadinessV1 {
+  const fallbackObservedAt = new Date().toISOString();
+  try {
+    return projectCapturedReadinessV1(
+      requirement,
+      snapshot,
+      options,
+      fallbackObservedAt,
+    );
+  } catch {
+    return invalidProjection(fallbackObservedAt);
+  }
+}
+
+function projectCapturedReadinessV1(
+  requirement: AiOperationReadinessRequirementV1,
+  snapshot: unknown,
+  options: ProjectAiOperationReadinessOptionsV1,
+  fallbackObservedAt: string,
+): ModuleAiOperationReadinessV1 {
+  const now = options.now ?? fallbackObservedAt;
+  if (
+    !validCanonicalAiTimestampV1(now) ||
+    !validAiOperationReadinessRequirementV1(requirement)
+  ) {
+    return unavailable(requirement, fallbackObservedAt, [
+      reason("CONTRACT_INVALID", false, "operation-requirement"),
+    ]);
+  }
+  const parsed = parseAiRuntimeReadinessV1(snapshot, now);
+  if (!parsed.ok) {
+    return unavailable(requirement, parsed.observedAt, parsed.reasons);
+  }
+  const runtime = parsed.value;
+  if (runtime.runtimeKind !== requirement.runtimeKind) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason(
+        "RUNTIME_KIND_MISMATCH",
+        false,
+        "runtimeKind",
+        requirement.runtimeKind,
+        runtime.runtimeKind,
+      ),
+    ]);
+  }
+  if (runtime.status === "unavailable") {
+    return unavailable(
+      requirement,
+      runtime.observedAt,
+      runtime.unavailableReasons,
+    );
+  }
+  const probe = runtime.downstreamProbe;
+  if (
+    probe.deploymentIdentity !== runtime.deployment.identity ||
+    probe.releaseDigest !== runtime.deployment.releaseDigest ||
+    probe.offersDigest !== runtime.deployment.offersDigest
+  ) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("PROBE_ATTESTATION_MISMATCH", false, "downstream"),
+    ]);
+  }
+  if (
+    computeAiRuntimeOffersDigestV1(runtime.offers) !==
+    runtime.deployment.offersDigest
+  ) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("OFFERS_DIGEST_MISMATCH", false, "offers"),
+    ]);
+  }
+  const checkedAt = Date.parse(probe.checkedAt);
+  const validUntil = Date.parse(probe.validUntil);
+  const observedAt = Date.parse(runtime.observedAt);
+  const nowValue = Date.parse(now);
+  if (checkedAt > nowValue || observedAt > nowValue) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("PROBE_NOT_YET_VALID", true, "downstream"),
+    ]);
+  }
+  if (observedAt < checkedAt) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("CONTRACT_INVALID", false, "probe-chronology"),
+    ]);
+  }
+  if (validUntil - checkedAt > AI_RUNTIME_MAX_PROBE_TTL_SECONDS * 1_000) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("PROBE_TTL_EXCEEDED", false, "downstream"),
+    ]);
+  }
+  if (checkedAt >= validUntil) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("CONTRACT_INVALID", false, "probe-chronology"),
+    ]);
+  }
+  if (nowValue >= validUntil) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("PROBE_STALE", true, "downstream"),
+    ]);
+  }
+  const deploymentReason = compareDeployment(
+    requirement.expectedDeployment,
+    runtime.deployment,
+  );
+  const trustedDegradation =
+    deploymentReason &&
+    acceptsTrustedRuntimeDegradationV1(
+      requirement,
+      runtime.deployment,
+      runtime.offers,
+      options.trustedFullAttestation,
+    );
+  if (deploymentReason && !trustedDegradation) {
+    return unavailable(requirement, runtime.observedAt, [deploymentReason]);
+  }
+
+  let offers: readonly AiRuntimeOfferV1[] = runtime.offers;
+  if (requirement.variant) {
+    offers = offers.filter(({ variant }) => variant === requirement.variant);
+    if (!offers.length) {
+      return unavailable(requirement, runtime.observedAt, [
+        reason("VARIANT_UNSUPPORTED", false, requirement.variant),
+      ]);
+    }
+  }
+  offers = offers.filter(({ capabilities }) =>
+    includesAll(capabilities, requirement.requiredCapabilities),
+  );
+  if (!offers.length) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("CAPABILITY_MISSING", false, "operation.requiredCapabilities"),
+    ]);
+  }
+  offers = offers.filter(({ inputModalities }) =>
+    includesAll(inputModalities, requirement.inputModalities),
+  );
+  if (!offers.length) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason(
+        "INPUT_MODALITY_UNSUPPORTED",
+        false,
+        requirement.inputModalities.join(","),
+      ),
+    ]);
+  }
+  offers = offers.filter(({ outputModalities }) =>
+    includesAll(outputModalities, requirement.outputModalities),
+  );
+  if (!offers.length) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason(
+        "OUTPUT_MODALITY_UNSUPPORTED",
+        false,
+        requirement.outputModalities.join(","),
+      ),
+    ]);
+  }
+  const beforeLimits = offers;
+  offers = offers.filter((offer) =>
+    supportsAiOperationLimitsV1(offer, requirement.limits),
+  );
+  if (!offers.length) {
+    const mismatch = findAiOperationLimitMismatchV1(
+      beforeLimits,
+      requirement.limits,
+    );
+    return unavailable(requirement, runtime.observedAt, [
+      reason(
+        "LIMIT_INSUFFICIENT",
+        false,
+        mismatch.key,
+        mismatch.required,
+        mismatch.available,
+      ),
+    ]);
+  }
+  offers = offers.filter((offer) =>
+    supportsAiOperationResourcesV1(offer, requirement.resources),
+  );
+  if (!offers.length) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("RESOURCE_LIMIT_INSUFFICIENT", false, "resources"),
+    ]);
+  }
+  const [first, ...rest] = offers;
+  if (!first) {
+    return unavailable(requirement, runtime.observedAt, [
+      reason("CONTRACT_INVALID", false, "offers"),
+    ]);
+  }
+  return {
+    schemaVersion: AI_RUNTIME_READINESS_SCHEMA_VERSION,
+    operationKey: requirement.operationKey,
+    runtimeKind: requirement.runtimeKind,
+    observedAt: runtime.observedAt,
+    status: "ready",
+    validUntil: probe.validUntil,
+    deployment: trustedDegradation
+      ? requirement.expectedDeployment
+      : runtime.deployment,
+    offers: [first, ...rest],
+    unavailableReasons: [],
+  };
+}
+
+function compareDeployment(
+  expected: AiRuntimeDeploymentV1,
+  actual: AiRuntimeDeploymentV1,
+): AiReadinessReasonV1 | null {
+  if (expected.key !== actual.key) {
+    return reason("DEPLOYMENT_KEY_MISMATCH", false, "deployment.key");
+  }
+  if (expected.identity !== actual.identity) {
+    return reason("DEPLOYMENT_IDENTITY_MISMATCH", false, "deployment.identity");
+  }
+  if (expected.releaseDigest !== actual.releaseDigest) {
+    return reason(
+      "RELEASE_DIGEST_MISMATCH",
+      false,
+      "deployment.releaseDigest",
+      expected.releaseDigest,
+      actual.releaseDigest,
+    );
+  }
+  return expected.offersDigest === actual.offersDigest
+    ? null
+    : reason(
+        "OFFERS_DIGEST_MISMATCH",
+        false,
+        "deployment.offersDigest",
+        expected.offersDigest,
+        actual.offersDigest,
+      );
+}
+
+function includesAll<T>(available: readonly T[], required: readonly T[]) {
+  return required.every((value) => available.includes(value));
+}
+
+function unavailable(
+  requirement: unknown,
+  observedAt: string,
+  reasons: readonly [AiReadinessReasonV1, ...AiReadinessReasonV1[]],
+): ModuleAiOperationReadinessV1 {
+  const operation = safeAiOperationIdentityV1(requirement);
+  return {
+    schemaVersion: AI_RUNTIME_READINESS_SCHEMA_VERSION,
+    operationKey: operation.operationKey,
+    runtimeKind: operation.runtimeKind,
+    observedAt,
+    status: "unavailable",
+    deployment: null,
+    offers: [],
+    unavailableReasons: reasons,
+  };
+}
+
+function invalidProjection(observedAt: string): ModuleAiOperationReadinessV1 {
+  return {
+    schemaVersion: AI_RUNTIME_READINESS_SCHEMA_VERSION,
+    operationKey: "invalid-operation",
+    runtimeKind: "agent",
+    observedAt,
+    status: "unavailable",
+    deployment: null,
+    offers: [],
+    unavailableReasons: [{ code: "CONTRACT_INVALID", retryable: false }],
+  };
+}
+
+function reason(
+  code: AiReadinessReasonCodeV1,
+  retryable: boolean,
+  subject?: string,
+  expected?: string | number,
+  actual?: string | number,
+): AiReadinessReasonV1 {
+  return {
+    code,
+    retryable,
+    ...(subject === undefined ? {} : { subject }),
+    ...(expected === undefined ? {} : { expected }),
+    ...(actual === undefined ? {} : { actual }),
+  };
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-requirement.ts

@@ -0,0 +1,31 @@
+import {
+  AI_RUNTIME_KINDS_V1,
+  type AiRuntimeKindV1,
+} from "@southwind-ai/shared";
+import { validAiContractStableKeyV1 } from "./ai-runtime-readiness-keys.js";
+import { isAiRuntimeRecordV1 } from "./ai-runtime-readiness-values.js";
+
+const runtimeKinds = new Set<AiRuntimeKindV1>(AI_RUNTIME_KINDS_V1);
+export { validAiOperationReadinessRequirementV1 } from "@southwind-ai/shared";
+
+export function safeAiOperationIdentityV1(requirement: unknown): {
+  operationKey: string;
+  runtimeKind: AiRuntimeKindV1;
+} {
+  if (!isAiRuntimeRecordV1(requirement)) {
+    return {
+      operationKey: "invalid-operation",
+      runtimeKind: AI_RUNTIME_KINDS_V1[0],
+    };
+  }
+  return {
+    operationKey: validAiContractStableKeyV1(requirement.operationKey)
+      ? requirement.operationKey
+      : "invalid-operation",
+    runtimeKind:
+      typeof requirement.runtimeKind === "string" &&
+      runtimeKinds.has(requirement.runtimeKind as AiRuntimeKindV1)
+        ? (requirement.runtimeKind as AiRuntimeKindV1)
+        : AI_RUNTIME_KINDS_V1[0],
+  };
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-time.ts

@@ -0,0 +1,16 @@
+const canonicalUtcTimestampPattern =
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+export function parseCanonicalAiTimestampV1(value: unknown): string | null {
+  if (typeof value !== "string" || !canonicalUtcTimestampPattern.test(value)) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return !Number.isNaN(parsed.valueOf()) && parsed.toISOString() === value
+    ? value
+    : null;
+}
+
+export function validCanonicalAiTimestampV1(value: unknown): boolean {
+  return parseCanonicalAiTimestampV1(value) !== null;
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-trust.ts

@@ -0,0 +1,84 @@
+import type {
+  AiOperationReadinessRequirementV1,
+  AiRuntimeDeploymentV1,
+  AiRuntimeOfferLimitsV1,
+  AiRuntimeOfferV1,
+} from "./ai-runtime-readiness.js";
+import { computeAiRuntimeOffersDigestV1 } from "./ai-runtime-readiness-digest.js";
+
+export interface AiRuntimeTrustedFullAttestationV1 {
+  readonly deployment: AiRuntimeDeploymentV1;
+  readonly offers: readonly [AiRuntimeOfferV1, ...AiRuntimeOfferV1[]];
+}
+
+export function acceptsTrustedRuntimeDegradationV1(
+  requirement: AiOperationReadinessRequirementV1,
+  currentDeployment: AiRuntimeDeploymentV1,
+  currentOffers: readonly AiRuntimeOfferV1[],
+  trusted: AiRuntimeTrustedFullAttestationV1 | undefined,
+) {
+  if (
+    !trusted ||
+    !sameDeployment(trusted.deployment, requirement.expectedDeployment) ||
+    currentDeployment.key !== trusted.deployment.key ||
+    currentDeployment.identity !== trusted.deployment.identity ||
+    computeAiRuntimeOffersDigestV1(trusted.offers) !==
+      trusted.deployment.offersDigest
+  ) {
+    return false;
+  }
+  const fullByVariant = new Map(
+    trusted.offers.map((offer) => [offer.variant, offer]),
+  );
+  return currentOffers.every((offer) => {
+    const full = fullByVariant.get(offer.variant);
+    return Boolean(
+      full &&
+      subset(offer.capabilities, full.capabilities) &&
+      subset(offer.inputModalities, full.inputModalities) &&
+      subset(offer.outputModalities, full.outputModalities) &&
+      noLimitExpansion(offer.limits, full.limits),
+    );
+  });
+}
+
+function sameDeployment(
+  left: AiRuntimeDeploymentV1,
+  right: AiRuntimeDeploymentV1,
+) {
+  return (
+    left.key === right.key &&
+    left.identity === right.identity &&
+    left.releaseDigest === right.releaseDigest &&
+    left.offersDigest === right.offersDigest
+  );
+}
+
+function subset<T>(current: readonly T[], full: readonly T[]) {
+  return current.every((value) => full.includes(value));
+}
+
+function noLimitExpansion(
+  current: AiRuntimeOfferLimitsV1,
+  full: AiRuntimeOfferLimitsV1,
+) {
+  const keys = [
+    "maxDurationSeconds",
+    "maxInputBytes",
+    "maxOutputBytes",
+    "maxUnits",
+    "maxMediaDurationSeconds",
+    "maxArtifacts",
+    "maxPixelsPerArtifact",
+    "maxConcurrentRuns",
+    "maxQueueDepth",
+  ] as const;
+  return keys.every((key) => {
+    const currentValue = current[key];
+    const fullValue = full[key];
+    return (
+      currentValue === undefined ||
+      (fullValue !== undefined && currentValue <= fullValue)
+    );
+  });
+}