veryfront 0.1.533 → 0.1.535

package/src/src/agent/testing/index.ts

@@ -18,12 +18,17 @@ export {
 } from "./agent-tester.js";
 
 export {
+  assertCompleted as assertDurableRunCanaryCompleted,
+  assertNoMalformedCreateFileToolCalls,
+  collectAssistantText,
   createDurableRunCanaryApiClient,
   createDurableRunCanaryRunner,
+  DEFAULT_DURABLE_RUN_CANARY_TIMEOUT_MS,
   type DurableRunCanaryApiClient,
   type DurableRunCanaryApiConfig,
   type DurableRunCanaryCase,
   type DurableRunCanaryCreateRootRunInput,
+  type DurableRunCanaryEnvironment,
   type DurableRunCanaryMessage,
   type DurableRunCanaryPreparedCase,
   type DurableRunCanaryResult,
@@ -32,8 +37,11 @@ export {
   type DurableRunCanaryRunSummary,
   type DurableRunCanarySendUserMessageInput,
   type DurableRunCanaryStartRunInput,
+  findAssistantMessage,
   getDurableRunCanaryMessageSchema,
   parseDurableRunCanaryRunSummary,
+  resolveDurableRunCanaryEnvironment,
+  stringifyUnknown,
 } from "./durable-run-canaries/index.js";
 
 export {
@@ -61,9 +69,11 @@ export {
   createPlainTextPdf,
   createSkippedEvalResult,
   DEFAULT_LIVE_EVAL_AREA_TAG_RULES,
+  DEFAULT_LIVE_EVAL_ENDPOINT,
   DEFAULT_LIVE_EVAL_OPTIONAL_JUDGE_CASE_PREFIXES,
   deleteLiveEvalConversation,
   deleteLiveEvalProjectFile,
+  evaluateRuntimeConfidenceEnv,
   getLiveEvalProjectFile,
   hasEveryLiveEvalTag,
   hasFinished,
@@ -80,6 +90,7 @@ export {
   type LiveEvalConversationInput,
   type LiveEvalCreateConversationInput,
   type LiveEvalCreateReleaseInput,
+  type LiveEvalEnvironment,
   type LiveEvalInputRequestInput,
   type LiveEvalInputRequestRecord,
   type LiveEvalInputResponseValues,
@@ -98,7 +109,10 @@ export {
   type LiveEvalSubmitInputResponseInput,
   type LiveEvalWaitForOpenInputRequestInput,
   type PreparedLiveEvalInput,
+  printRuntimeConfidencePreflight,
+  resolveLiveEvalEnvironment,
   resolveLiveEvalRequestedCaseIds,
+  type RuntimeConfidencePreflightResult,
   type RuntimePerformanceSummary,
   selectLiveEvalCases,
   submitLiveEvalInputResponse,

package/src/src/agent/testing/live-evals/cli-runner.ts

@@ -0,0 +1,234 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { cwd as getProcessCwd } from "node:process";
+import { buildRuntimePerformanceSummary, type LiveEvalRuntime } from "./performance.js";
+import {
+  buildLiveEvalCaseTagSummary,
+  buildLiveEvalRuntimeSummary,
+  buildLiveEvalStatusSummary,
+  resolveLiveEvalRequestedCaseIds,
+  selectLiveEvalCases,
+} from "./report.js";
+import {
+  containsSkillLoad,
+  countStepStartedEvents,
+  createLiveEvalCaseSupport,
+  hasFinished,
+  type LiveEvalCase,
+  type LiveEvalRunnerConfig,
+} from "./runner.js";
+import { getLiveEvalProjectFile, type LiveEvalApiContext } from "./api-client.js";
+import { resolveLiveEvalEnvironment } from "./environment.js";
+import type { LiveEvalResultRecord } from "./result.js";
+
+type EnvRecord = Record<string, string | undefined>;
+
+export interface LiveEvalCliCaseGroups {
+  readOnlyCases: LiveEvalCase[];
+  writeCases: LiveEvalCase[];
+  experimentalWriteCases: LiveEvalCase[];
+}
+
+export interface LiveEvalCliCaseFactoryInput {
+  authToken: string;
+  endpoint: string;
+  projectId: string | null;
+  branchId: string | null;
+  model: string | null;
+  requestTimeoutMs: number;
+  enableLlmJudge: boolean;
+  hasFinished: typeof hasFinished;
+  containsSkillLoad: typeof containsSkillLoad;
+  countStepStartedEvents: typeof countStepStartedEvents;
+  verifyFileExists: ReturnType<typeof createLiveEvalCaseSupport>["verifyFileExists"];
+  withJudge: ReturnType<typeof createLiveEvalCaseSupport>["withJudge"];
+  judgeLlm: ReturnType<typeof createLiveEvalCaseSupport>["judgeLlm"];
+}
+
+export interface RunLiveEvalCliInput {
+  env: EnvRecord;
+  caseSets: Record<string, readonly string[]>;
+  createCases: (input: LiveEvalCliCaseFactoryInput) => LiveEvalCliCaseGroups;
+  runtimes?: readonly LiveEvalRuntime[];
+  cwd?: string;
+  log?: (message: string) => void;
+  error?: (message: string) => void;
+  createCaseSupport?: (
+    config: LiveEvalRunnerConfig,
+  ) => ReturnType<typeof createLiveEvalCaseSupport>;
+}
+
+function splitCsvEnv(value: string | undefined): Set<string> {
+  return new Set(
+    (value ?? "")
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter((entry) => entry.length > 0),
+  );
+}
+
+function createTimestampedReportPath(input: {
+  cwd: string;
+  directory: string;
+}): string {
+  return resolve(
+    input.cwd,
+    ".omx/logs",
+    input.directory,
+    `${new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-")}.json`,
+  );
+}
+
+export async function runLiveEvalCli(input: RunLiveEvalCliInput): Promise<number> {
+  const log = input.log ?? console.log;
+  const error = input.error ?? console.error;
+  const cwd = input.cwd ?? getProcessCwd();
+  const { endpoint, authToken, apiUrl, projectId, branchId, model } = resolveLiveEvalEnvironment(
+    input.env,
+  );
+  const requestedRuntimeSelection = input.runtimes ?? ["framework"];
+  const runWriteEvals = input.env.AG_UI_EVAL_WRITE === "1";
+  const runExperimentalWriteEvals = input.env.AG_UI_EVAL_EXPERIMENTAL === "1";
+  const requestTimeoutMs = Number(input.env.AG_UI_EVAL_TIMEOUT_MS ?? "240000");
+  const progressLogIntervalMs = Number(input.env.AG_UI_EVAL_PROGRESS_MS ?? "15000");
+  const reportPath = input.env.AG_UI_EVAL_REPORT_PATH ??
+    createTimestampedReportPath({ cwd, directory: "ag-ui-live-evals" });
+  const requestedCaseIds = splitCsvEnv(input.env.AG_UI_EVAL_CASES);
+  const requestedCaseTags = splitCsvEnv(input.env.AG_UI_EVAL_TAGS);
+  const requestedCaseSetId = input.env.AG_UI_EVAL_CASE_SET?.trim() || null;
+  const enableLlmJudge = input.env.AG_UI_EVAL_LLM_JUDGE === "1";
+
+  const apiContext: LiveEvalApiContext = {
+    apiUrl,
+    authToken,
+    projectId: projectId ?? null,
+  };
+  const createCaseSupport = input.createCaseSupport ?? createLiveEvalCaseSupport;
+  const { judgeLlm, runEval, verifyFileExists, withJudge } = createCaseSupport({
+    endpoint,
+    authToken,
+    apiUrl,
+    projectId: projectId ?? null,
+    branchId: branchId ?? null,
+    model: model ?? null,
+    requestTimeoutMs,
+    progressLogIntervalMs,
+    enableLlmJudge,
+    readProjectFile: (readerInput) => getLiveEvalProjectFile(apiContext, readerInput),
+  });
+
+  const { readOnlyCases, writeCases, experimentalWriteCases } = input.createCases({
+    authToken,
+    endpoint,
+    projectId: projectId ?? null,
+    branchId: branchId ?? null,
+    model: model ?? null,
+    requestTimeoutMs,
+    enableLlmJudge,
+    hasFinished,
+    containsSkillLoad,
+    countStepStartedEvents,
+    verifyFileExists,
+    withJudge,
+    judgeLlm,
+  });
+
+  if (authToken.length === 0) {
+    error("Missing VERYFRONT_TOKEN");
+    return 1;
+  }
+
+  log(`AG-UI live evals -> ${endpoint}`);
+  log(`Veryfront API -> ${apiUrl}`);
+  log(`Project scope -> ${projectId ?? "none"}`);
+  log(`Runtime -> ${requestedRuntimeSelection.join(", ")}`);
+  log(`Write evals -> ${runWriteEvals ? "enabled" : "disabled"}`);
+  log(`Experimental evals -> ${runExperimentalWriteEvals ? "enabled" : "disabled"}`);
+  log(`Case set -> ${requestedCaseSetId ?? "none"}`);
+  log(`Case tags -> ${requestedCaseTags.size > 0 ? [...requestedCaseTags].join(", ") : "none"}`);
+
+  const allCases = [...readOnlyCases, ...writeCases, ...experimentalWriteCases];
+  const resolvedRequestedCaseIds = resolveLiveEvalRequestedCaseIds({
+    caseSets: input.caseSets,
+    requestedCaseIds,
+    requestedCaseSetId,
+  });
+  const cases = selectLiveEvalCases({
+    allCases,
+    readOnlyCases,
+    writeCases,
+    experimentalWriteCases,
+    requestedCaseIds: resolvedRequestedCaseIds,
+    requestedCaseTags,
+    runWriteEvals,
+    runExperimentalWriteEvals,
+  });
+  const selectedCaseTagSummary = buildLiveEvalCaseTagSummary(cases);
+
+  if (cases.length === 0) {
+    error("No eval cases selected.");
+    return 1;
+  }
+
+  const results: LiveEvalResultRecord[] = [];
+
+  for (const runtime of requestedRuntimeSelection) {
+    log(`\n[runtime] ${runtime}`);
+    for (const testCase of cases) {
+      log(`\n[run] ${runtime} :: ${testCase.label}`);
+      const result = await runEval(testCase, runtime);
+      results.push(result);
+      log(`[${runtime}] [${result.status}] ${result.details}`);
+    }
+  }
+
+  const summary = buildLiveEvalStatusSummary(results);
+  const runtimeSummary = buildLiveEvalRuntimeSummary(requestedRuntimeSelection, results);
+  const runtimePerformanceSummary = buildRuntimePerformanceSummary(results);
+
+  log("\nSummary");
+  log(`passed: ${summary.passed}`);
+  log(`failed: ${summary.failed}`);
+  log(`skipped: ${summary.skipped}`);
+  for (const runtime of requestedRuntimeSelection) {
+    const currentRuntimeSummary = runtimeSummary[runtime];
+    log(
+      `${runtime}: passed=${currentRuntimeSummary.passed} failed=${currentRuntimeSummary.failed} skipped=${currentRuntimeSummary.skipped}`,
+    );
+    const performance = runtimePerformanceSummary[runtime];
+    log(
+      `${runtime}: avg=${performance.avgDurationMs}ms p50=${performance.p50DurationMs}ms p95=${performance.p95DurationMs}ms min=${performance.minDurationMs}ms max=${performance.maxDurationMs}ms`,
+    );
+  }
+
+  await mkdir(dirname(reportPath), { recursive: true });
+  await writeFile(
+    reportPath,
+    JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        endpoint,
+        apiUrl,
+        projectId: projectId ?? null,
+        runtimes: requestedRuntimeSelection,
+        writeEvals: runWriteEvals,
+        requestedCaseIds: [...resolvedRequestedCaseIds],
+        requestedCaseTags: [...requestedCaseTags],
+        requestedCaseSetId,
+        caseMetadata: Object.fromEntries(
+          cases.map((testCase) => [testCase.id, testCase.metadata ?? { tags: [] }]),
+        ),
+        selectedCaseTagSummary,
+        results,
+        summary,
+        runtimeSummary,
+        runtimePerformanceSummary,
+      },
+      null,
+      2,
+    ),
+  );
+  log(`report: ${reportPath}`);
+
+  return summary.failed > 0 ? 1 : 0;
+}

package/src/src/agent/testing/live-evals/environment.ts

@@ -0,0 +1,31 @@
+import { type AgentServiceConfigInput, parseAgentServiceConfig } from "../../service/config.js";
+
+export interface LiveEvalEnvironment {
+  endpoint: string;
+  authToken: string;
+  apiUrl: string;
+  projectId: string | undefined;
+  branchId: string | undefined;
+  model: string | undefined;
+}
+
+export const DEFAULT_LIVE_EVAL_ENDPOINT = "http://127.0.0.1:3001/api/ag-ui";
+
+export function resolveLiveEvalEnvironment(
+  env: AgentServiceConfigInput = {},
+): LiveEvalEnvironment {
+  return {
+    endpoint: typeof env.AG_UI_EVAL_ENDPOINT === "string"
+      ? env.AG_UI_EVAL_ENDPOINT
+      : DEFAULT_LIVE_EVAL_ENDPOINT,
+    authToken: typeof env.VERYFRONT_TOKEN === "string" ? env.VERYFRONT_TOKEN : "",
+    apiUrl: typeof env.VERYFRONT_API_URL === "string"
+      ? env.VERYFRONT_API_URL
+      : parseAgentServiceConfig(env).VERYFRONT_API_URL,
+    projectId: typeof env.AG_UI_EVAL_PROJECT_ID === "string"
+      ? env.AG_UI_EVAL_PROJECT_ID
+      : undefined,
+    branchId: typeof env.AG_UI_EVAL_BRANCH_ID === "string" ? env.AG_UI_EVAL_BRANCH_ID : undefined,
+    model: typeof env.AG_UI_EVAL_MODEL === "string" ? env.AG_UI_EVAL_MODEL : undefined,
+  };
+}

package/src/src/agent/testing/live-evals/index.ts

@@ -1,3 +1,14 @@
+export {
+  type LiveEvalCliCaseFactoryInput,
+  type LiveEvalCliCaseGroups,
+  runLiveEvalCli,
+  type RunLiveEvalCliInput,
+} from "./cli-runner.js";
+export {
+  DEFAULT_LIVE_EVAL_ENDPOINT,
+  type LiveEvalEnvironment,
+  resolveLiveEvalEnvironment,
+} from "./environment.js";
 export {
   cancelLiveEvalInputRequest,
   createLiveEvalApiClient,
@@ -30,6 +41,11 @@ export {
   containsOrderedSubsequence,
   createPlainTextPdf,
 } from "./formatting.js";
+export {
+  evaluateRuntimeConfidenceEnv,
+  printRuntimeConfidencePreflight,
+  type RuntimeConfidencePreflightResult,
+} from "./preflight.js";
 export {
   buildRuntimePerformanceSummary,
   type LiveEvalResultForPerformance,

package/src/src/agent/testing/live-evals/preflight.ts

@@ -0,0 +1,42 @@
+import { type AgentServiceConfigInput, parseAgentServiceConfig } from "../../service/config.js";
+
+export interface RuntimeConfidencePreflightResult {
+  ok: boolean;
+  resolvedApiUrl: string;
+  messages: string[];
+}
+
+export function evaluateRuntimeConfidenceEnv(
+  env: AgentServiceConfigInput = {},
+  resolvedApiUrl: string = parseAgentServiceConfig(env).VERYFRONT_API_URL,
+): RuntimeConfidencePreflightResult {
+  const messages: string[] = [`Resolved VERYFRONT_API_URL: ${resolvedApiUrl}`];
+  let hasBlockers = false;
+
+  if (typeof env.VERYFRONT_TOKEN !== "string" || env.VERYFRONT_TOKEN.length === 0) {
+    hasBlockers = true;
+    messages.push("BLOCKER: VERYFRONT_TOKEN is missing");
+  }
+  if (typeof env.AG_UI_EVAL_PROJECT_ID !== "string" || env.AG_UI_EVAL_PROJECT_ID.length === 0) {
+    hasBlockers = true;
+    messages.push("BLOCKER: AG_UI_EVAL_PROJECT_ID is missing");
+  }
+
+  if (!hasBlockers) {
+    messages.push("Runtime-confidence preflight: PASS");
+    return { ok: true, resolvedApiUrl, messages };
+  }
+
+  messages.push("Runtime-confidence preflight: FAIL");
+  return { ok: false, resolvedApiUrl, messages };
+}
+
+export function printRuntimeConfidencePreflight(
+  result: RuntimeConfidencePreflightResult,
+  output: Pick<Console, "error" | "log"> = console,
+): void {
+  for (const message of result.messages) {
+    const writer = result.ok ? output.log : output.error;
+    writer(message);
+  }
+}

package/src/src/extensions/builtin-extensions.ts

@@ -84,7 +84,10 @@ function createBuiltinLLMProviderExtension(
     extension: {
       name: definition.extensionName,
       version: "0.1.0",
-      capabilities: [{ type: "contract", name: `LLMProvider:${provider.id}` }],
+      contracts: {
+        requires: [LLMProviderRegistryName],
+      },
+      capabilities: [],
       setup(ctx) {
         const registry = ctx.require<LLMProviderRegistry>(LLMProviderRegistryName);
         didRegister = registerBuiltinLLMProvider(registry, provider);

package/src/src/extensions/capabilities.ts

@@ -11,10 +11,6 @@ import type { Capability, ExtensionLogger } from "./types.js";
  */
 export function formatCapabilities(capabilities: Capability[]): string[] {
   return capabilities.map((cap) => {
-    if (cap.type === "contract") {
-      return `contract: ${cap.name as string}`;
-    }
-
     const { type, ...rest } = cap;
     const extras = Object.keys(rest);
     if (extras.length === 0) return type;
@@ -53,7 +49,7 @@ const DENO_PERMISSION_MAP: Record<string, PermissionMapping> = {
 
 /**
  * Map capabilities to Deno CLI permission flags.
- * Skips non-system capabilities (e.g., "contract").
+ * Skips capabilities without a Deno permission mapping.
  */
 export function mapToDenoPermissions(capabilities: Capability[]): string[] {
   const seen = new Set<string>();

package/src/src/extensions/discovery.ts

@@ -10,7 +10,7 @@ import * as dntShim from "../../_dnt.shims.js";
 
 
 import { join } from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
-import type { Capability, ResolvedExtension } from "./types.js";
+import type { Capability, PackageContractMetadata, ResolvedExtension } from "./types.js";
 
 /**
  * Metadata extracted from a package.json that declares itself
@@ -19,6 +19,7 @@ import type { Capability, ResolvedExtension } from "./types.js";
 export interface PackageMetadata {
   isExtension: true;
   capabilities: Capability[];
+  contracts?: PackageContractMetadata;
 }
 
 function isCapability(value: unknown): value is Capability {
@@ -29,6 +30,27 @@ function isCapability(value: unknown): value is Capability {
   return typeof cap.type === "string" && cap.type.length > 0;
 }
 
+function parseStringList(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const entries = value.filter((entry): entry is string =>
+    typeof entry === "string" && entry.length > 0
+  );
+  return entries.length > 0 ? entries : undefined;
+}
+
+function parseContractMetadata(value: unknown): PackageContractMetadata | undefined {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const raw = value as Record<string, unknown>;
+  const contracts: PackageContractMetadata = {};
+  const provides = parseStringList(raw.provides);
+  const requires = parseStringList(raw.requires);
+  if (provides) contracts.provides = provides;
+  if (requires) contracts.requires = requires;
+  return provides || requires ? contracts : undefined;
+}
+
 /**
  * Parse veryfront extension metadata from a package.json-like object.
  *
@@ -55,8 +77,11 @@ export function parsePackageMetadata(
   const capabilities: Capability[] = Array.isArray(meta.capabilities)
     ? meta.capabilities.filter(isCapability)
     : [];
+  const contracts = parseContractMetadata(meta.contracts);
 
-  return { isExtension: true, capabilities };
+  return contracts
+    ? { isExtension: true, capabilities, contracts }
+    : { isExtension: true, capabilities };
 }
 
 /**

package/src/src/extensions/index.ts

@@ -29,6 +29,7 @@ export type {
   Extension,
   ExtensionConfigEntry,
   ExtensionContext,
+  ExtensionContractMetadata,
   ExtensionFactory,
   ExtensionLogger,
   ExtensionSource,

package/src/src/extensions/loader.ts

@@ -84,15 +84,11 @@ export class ExtensionLoader {
       const ext = resolved.extension;
       extByName.set(ext.name, resolved);
 
-      if (ext.provides) {
-        for (const contract of Object.keys(ext.provides)) {
-          providerOf.set(contract, ext.name);
-        }
+      for (const contract of providedContractNames(ext)) {
+        providerOf.set(contract, ext.name);
       }
 
-      const contracts = ext.capabilities
-        .filter((c) => c.type === "contract")
-        .map((c) => c.name as string);
+      const contracts = requiredContractNames(ext);
       if (contracts.length > 0) {
         consumesContracts.set(ext.name, contracts);
       }
@@ -168,8 +164,10 @@ export class ExtensionLoader {
       register(name, impl);
     }
 
+    const loadOrder = this.topologicalSort(this.flattenPresets(extensions));
+
     // Check for contract conflicts before loading
-    const conflicts = detectConflicts(extensions);
+    const conflicts = detectConflicts(loadOrder);
     if (conflicts.length > 0) {
       const details = conflicts
         .map((c) => `"${c.contract}" provided by: ${c.providers.map((p) => p.name).join(", ")}`)
@@ -183,9 +181,9 @@ export class ExtensionLoader {
     // provider later in the iteration order cannot overwrite the winning impl
     // via register(). Without this, merged inputs (config -> package ->
     // project -> local-file) silently invert the documented source priority.
-    const contractWinner = selectContractProviders(extensions);
+    const contractWinner = selectContractProviders(loadOrder);
 
-    for (const resolved of extensions) {
+    for (const resolved of loadOrder) {
       const ext = resolved.extension;
 
       const issues = validateExtension(ext);
@@ -209,7 +207,12 @@ export class ExtensionLoader {
         const ctx: ExtensionContext = {
           get: <T>(contract: string) => tryResolve<T>(contract),
           require: <T>(contract: string) => resolveContract<T>(contract),
-          provide: <T>(contract: string, impl: T) => register(contract, impl),
+          provide: <T>(contract: string, impl: T) => {
+            const winner = contractWinner.get(contract);
+            if (!winner || winner === resolved) {
+              register(contract, impl);
+            }
+          },
           config: projectConfig,
           logger: this.logger,
         };
@@ -262,3 +265,18 @@ export class ExtensionLoader {
     if (hadSetupExtensions) reset();
   }
 }
+
+function providedContractNames(ext: Extension): string[] {
+  const names = new Set<string>();
+  for (const contract of Object.keys(ext.provides ?? {})) {
+    names.add(contract);
+  }
+  for (const contract of ext.contracts?.provides ?? []) {
+    names.add(contract);
+  }
+  return [...names];
+}
+
+function requiredContractNames(ext: Extension): string[] {
+  return ext.contracts?.requires ?? [];
+}

package/src/src/extensions/types.ts

@@ -13,6 +13,15 @@ export interface Capability {
   [key: string]: unknown;
 }
 
+export interface ExtensionContractMetadata {
+  /** Contracts this extension registers dynamically during setup(). */
+  provides?: string[];
+  /** Contracts this extension needs before setup() runs. */
+  requires?: string[];
+}
+
+export type PackageContractMetadata = ExtensionContractMetadata;
+
 export interface ExtensionContext {
   get<T>(contract: string): T | undefined;
   require<T>(contract: string): T;
@@ -32,6 +41,7 @@ export interface Extension {
   name: string;
   version: string;
   capabilities: Capability[];
+  contracts?: ExtensionContractMetadata;
   setup?(ctx: ExtensionContext): Promise<void> | void;
   teardown?(): Promise<void> | void;
   provides?: Record<string, unknown>;

package/src/src/extensions/validation.ts

@@ -37,9 +37,7 @@ export function selectContractProviders(
 ): Map<string, ResolvedExtension> {
   const winner = new Map<string, ResolvedExtension>();
   for (const resolved of extensions) {
-    const provides = resolved.extension.provides;
-    if (!provides) continue;
-    for (const contract of Object.keys(provides)) {
+    for (const contract of providedContractNames(resolved.extension)) {
       const current = winner.get(contract);
       if (
         !current ||
@@ -52,6 +50,30 @@ export function selectContractProviders(
   return winner;
 }
 
+function providedContractNames(extension: Extension): string[] {
+  return [
+    ...Object.keys(extension.provides ?? {}),
+    ...(extension.contracts?.provides ?? []),
+  ];
+}
+
+function validateContractList(
+  field: string,
+  value: unknown,
+  issues: string[],
+): void {
+  if (value === undefined) return;
+  if (!Array.isArray(value)) {
+    issues.push(`${field} must be an array`);
+    return;
+  }
+  for (let i = 0; i < value.length; i++) {
+    if (typeof value[i] !== "string" || value[i].length === 0) {
+      issues.push(`${field}[${i}] must be a non-empty string`);
+    }
+  }
+}
+
 /**
  * Validate the shape of an extension object.
  * Returns an array of issue descriptions (empty array = valid).
@@ -93,6 +115,27 @@ export function validateExtension(ext: unknown): string[] {
     }
   }
 
+  if (candidate.contracts !== undefined) {
+    if (
+      typeof candidate.contracts !== "object" ||
+      candidate.contracts === null ||
+      Array.isArray(candidate.contracts)
+    ) {
+      issues.push("contracts must be an object");
+    } else {
+      validateContractList(
+        "contracts.provides",
+        candidate.contracts.provides,
+        issues,
+      );
+      validateContractList(
+        "contracts.requires",
+        candidate.contracts.requires,
+        issues,
+      );
+    }
+  }
+
   return issues;
 }
 
@@ -109,10 +152,7 @@ export function detectConflicts(extensions: ResolvedExtension[]): ConflictInfo[]
   >();
 
   for (const resolved of extensions) {
-    const provides = resolved.extension.provides;
-    if (!provides) continue;
-
-    for (const contract of Object.keys(provides)) {
+    for (const contract of providedContractNames(resolved.extension)) {
       let list = contractProviders.get(contract);
       if (!list) {
         list = [];

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.533";
+export const VERSION = "0.1.535";