@ikon85/agent-workflow-kit 0.32.1 → 0.34.0

package/src/lib/routingSources/benchlm.mjs

@@ -0,0 +1,151 @@
+const SOURCE_ID = 'benchlm';
+const ARTIFACT_URL = 'https://benchlm.ai/data';
+const OWNER_URLS = Object.freeze({
+  'code-arena-webdev': 'https://arena.ai/leaderboard/code/webdev',
+  design2code: 'https://github.com/NoviScl/Design2Code',
+  'swe-bench-multimodal': 'https://www.swebench.com/multimodal',
+  vision2web: 'https://vision2web-bench.github.io/',
+});
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function timestamp(value, field) {
+  string(value, field);
+  if (!Number.isFinite(Date.parse(value))) throw new TypeError(`${field} must be an ISO timestamp`);
+  return value;
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+
+function validateUnique(items, identity, label) {
+  const identities = new Set();
+  for (const item of items) {
+    const id = identity(item);
+    if (identities.has(id)) throw new TypeError(`duplicate ${label} identity: ${id}`);
+    identities.add(id);
+  }
+}
+
+function ingest({ payload, snapshotHash, observedAt, expiresAt }) {
+  object(payload, 'BenchLM payload');
+  string(snapshotHash, 'snapshotHash');
+  timestamp(observedAt, 'observedAt');
+  timestamp(expiresAt, 'expiresAt');
+  if (Date.parse(expiresAt) <= Date.parse(observedAt)) {
+    throw new TypeError('expiresAt must follow observedAt');
+  }
+  if (payload.schemaVersion !== 1) throw new TypeError('BenchLM schemaVersion must be 1');
+  const generatedAt = timestamp(payload.generatedAt, 'BenchLM generatedAt');
+  const sourceLastUpdated = timestamp(
+    payload.sourceLastUpdated,
+    'BenchLM sourceLastUpdated',
+  );
+  if (Date.parse(sourceLastUpdated) > Date.parse(generatedAt)) {
+    throw new TypeError('BenchLM sourceLastUpdated cannot follow generatedAt');
+  }
+  if (!Array.isArray(payload.models)) throw new TypeError('BenchLM models must be an array');
+  if (!Array.isArray(payload.benchmarks)) {
+    throw new TypeError('BenchLM benchmarks must be an array');
+  }
+  if (!Array.isArray(payload.updates)) throw new TypeError('BenchLM updates must be an array');
+
+  validateUnique(
+    payload.models,
+    (model) => `${string(model.providerId, 'BenchLM model providerId')}:`
+      + string(model.modelId, 'BenchLM model modelId'),
+    'model',
+  );
+  validateUnique(
+    payload.benchmarks,
+    (benchmark) => string(benchmark.id, 'BenchLM benchmark id'),
+    'benchmark',
+  );
+
+  for (const benchmark of payload.benchmarks) {
+    object(benchmark, 'BenchLM benchmark');
+    const id = string(benchmark.id, 'BenchLM benchmark id');
+    const expectedUrl = OWNER_URLS[id];
+    if (expectedUrl && benchmark.ownerUrl !== expectedUrl) {
+      throw new TypeError(`BenchLM owner URL for ${id} must be ${expectedUrl}`);
+    }
+    string(benchmark.ownerUrl, `BenchLM benchmark ${id} ownerUrl`);
+    string(benchmark.status, `BenchLM benchmark ${id} status`);
+  }
+
+  const models = payload.models.map((model) => ({
+    providerId: string(model.providerId, 'BenchLM model providerId'),
+    modelId: string(model.modelId, 'BenchLM model modelId'),
+  }));
+  const signals = [];
+  for (const model of payload.models) {
+    object(model, 'BenchLM model');
+    string(model.family, 'BenchLM model family');
+    string(model.releasedAt, 'BenchLM model releasedAt');
+    object(model.pricing, 'BenchLM model pricing');
+    object(model.aggregates, 'BenchLM model aggregates');
+    signals.push({
+      kind: 'pricing-changed',
+      identity: `${model.providerId}:${model.modelId}`,
+      pricing: structuredClone(model.pricing),
+      observedAt: sourceLastUpdated,
+    });
+    if (Object.keys(model.aggregates).length > 0) {
+      signals.push({
+        kind: 'evidence-gap',
+        identity: `${model.providerId}:${model.modelId}`,
+        reason: 'aggregate-requires-owner-observation',
+        ownerCandidates: payload.benchmarks.map(({ id, ownerUrl }) => ({ id, ownerUrl })),
+      });
+    }
+  }
+  for (const update of payload.updates) {
+    object(update, 'BenchLM update');
+    signals.push({
+      kind: string(update.kind, 'BenchLM update kind'),
+      identity: string(update.identity, 'BenchLM update identity'),
+    });
+  }
+  if (payload.models.length > 0 || payload.benchmarks.length > 0 || payload.updates.length > 0) {
+    signals.push({
+      kind: 'freshness',
+      generatedAt,
+      sourceLastUpdated,
+      snapshotHash,
+    });
+    signals.push({
+      kind: 'corroboration-candidate',
+      benchmarkIds: payload.benchmarks.map(({ id }) => id),
+    });
+  }
+
+  return deepFreeze({
+    sourceId: SOURCE_ID,
+    models,
+    observations: [],
+    signals,
+  });
+}
+
+export const benchLmSource = Object.freeze({
+  sourceId: SOURCE_ID,
+  owner: 'BenchLM',
+  artifactUrl: ARTIFACT_URL,
+  ingest,
+});

package/src/lib/routingSources/codeArena.mjs

@@ -0,0 +1,162 @@
+import { frontendEvidenceWorkload } from '../frontendWorkloads.mjs';
+
+const OWNER_URL = 'https://arena.ai/leaderboard/code/webdev';
+const SOURCE_ID = 'code-arena-webdev';
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function finite(value, field) {
+  if (!Number.isFinite(value)) throw new TypeError(`${field} must be a finite number`);
+  return value;
+}
+
+function timestamp(value, field) {
+  string(value, field);
+  if (!Number.isFinite(Date.parse(value))) throw new TypeError(`${field} must be an ISO timestamp`);
+  return value;
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+
+function validateContext({ snapshotHash, observedAt, expiresAt }) {
+  string(snapshotHash, 'snapshotHash');
+  timestamp(observedAt, 'observedAt');
+  timestamp(expiresAt, 'expiresAt');
+  if (Date.parse(expiresAt) <= Date.parse(observedAt)) {
+    throw new TypeError('expiresAt must follow observedAt');
+  }
+}
+
+function hasOverlappingIntervals(observations) {
+  return observations.some((left, index) =>
+    observations.slice(index + 1).some((right) =>
+      left.score - left.uncertainty.value <= right.score + right.uncertainty.value
+      && right.score - right.uncertainty.value <= left.score + left.uncertainty.value));
+}
+
+function ingest({ payload, snapshotHash, observedAt, expiresAt }) {
+  object(payload, 'Code Arena payload');
+  validateContext({ snapshotHash, observedAt, expiresAt });
+  if (payload.schemaVersion !== 1) throw new TypeError('Code Arena schemaVersion must be 1');
+  string(payload.exportId, 'Code Arena exportId');
+  object(payload.benchmark, 'Code Arena benchmark');
+  if (payload.benchmark.id !== SOURCE_ID) {
+    throw new TypeError(`Code Arena benchmark identity must be ${SOURCE_ID}`);
+  }
+  if (payload.benchmark.url !== OWNER_URL) {
+    throw new TypeError(`Code Arena owner URL must be ${OWNER_URL}`);
+  }
+  string(payload.benchmark.owner, 'Code Arena benchmark owner');
+  string(payload.benchmark.version, 'Code Arena benchmark version');
+  object(payload.harness, 'Code Arena harness');
+  string(payload.harness.id, 'Code Arena harness id');
+  string(payload.harness.version, 'Code Arena harness version');
+  if (!Array.isArray(payload.rows) || payload.rows.length === 0) {
+    throw new TypeError('Code Arena rows must be a non-empty array');
+  }
+
+  const models = [];
+  const observations = [];
+  const modelIds = new Set();
+  const observationIds = new Set();
+  for (const [index, row] of payload.rows.entries()) {
+    object(row, `Code Arena rows[${index}]`);
+    const providerId = string(row.providerId, `Code Arena rows[${index}].providerId`);
+    const modelId = string(row.modelId, `Code Arena rows[${index}].modelId`);
+    const effort = string(row.effort, `Code Arena rows[${index}].effort`);
+    const domain = string(row.domain, `Code Arena rows[${index}].domain`);
+    const score = finite(row.score, `Code Arena rows[${index}].score`);
+    const interval = finite(
+      row.confidenceInterval,
+      `Code Arena rows[${index}].confidenceInterval`,
+    );
+    if (interval < 0) throw new TypeError('Code Arena confidenceInterval must be non-negative');
+    if (!['preliminary', 'established'].includes(row.status)) {
+      throw new TypeError(`Code Arena rows[${index}].status is unsupported`);
+    }
+    const sampleSize = finite(row.sampleSize, `Code Arena rows[${index}].sampleSize`);
+    const modelIdentity = `${providerId}:${modelId}`;
+    if (!modelIds.has(modelIdentity)) {
+      models.push({ providerId, modelId });
+      modelIds.add(modelIdentity);
+    }
+    const id = `${SOURCE_ID}:${payload.benchmark.version}:${domain}:${modelIdentity}:${effort}`;
+    if (observationIds.has(id)) {
+      throw new TypeError(`duplicate observation identity: ${id}`);
+    }
+    observationIds.add(id);
+    object(row.cost, `Code Arena rows[${index}].cost`);
+    observations.push({
+      id,
+      providerId,
+      modelId,
+      effort,
+      workload: frontendEvidenceWorkload({
+        workload: 'frontend-greenfield',
+        frontendDomain: domain,
+        axis: 'visual-preference',
+      }),
+      harness: {
+        id: payload.harness.id,
+        version: payload.harness.version,
+      },
+      score,
+      source: {
+        id: SOURCE_ID,
+        owner: payload.benchmark.owner,
+        url: payload.benchmark.url,
+        benchmark: SOURCE_ID,
+        version: payload.benchmark.version,
+        snapshotHash,
+      },
+      uncertainty: {
+        kind: 'confidence-interval',
+        value: interval,
+        status: row.status,
+        sampleSize,
+      },
+      freshness: { observedAt, expiresAt },
+      cost: {
+        amount: finite(row.cost.amount, `Code Arena rows[${index}].cost.amount`),
+        currency: string(row.cost.currency, `Code Arena rows[${index}].cost.currency`),
+        unit: string(row.cost.unit, `Code Arena rows[${index}].cost.unit`),
+      },
+    });
+  }
+
+  return deepFreeze({
+    sourceId: SOURCE_ID,
+    models,
+    observations,
+    diagnostics: {
+      overlappingUncertainty: hasOverlappingIntervals(observations),
+      preliminaryObservationIds: observations
+        .filter(({ uncertainty }) => uncertainty.status === 'preliminary')
+        .map(({ id }) => id),
+    },
+  });
+}
+
+export const codeArenaSource = Object.freeze({
+  sourceId: SOURCE_ID,
+  owner: 'Arena',
+  artifactUrl: OWNER_URL,
+  ingest,
+});

package/src/lib/routingSources/deepswe.mjs

@@ -0,0 +1,106 @@
+const SOURCE_ID = 'deepswe';
+const OWNER = 'DataCurve';
+const ARTIFACT_URL =
+  'https://deepswe.datacurve.ai/artifacts/v1.1/leaderboard-live.json';
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function number(value, field) {
+  if (!Number.isFinite(value)) throw new TypeError(`${field} must be a finite number`);
+  return value;
+}
+
+function context({ snapshotHash, observedAt, expiresAt }) {
+  string(snapshotHash, 'snapshotHash');
+  if (!Number.isFinite(Date.parse(observedAt))) {
+    throw new TypeError('observedAt must be an ISO timestamp');
+  }
+  if (!Number.isFinite(Date.parse(expiresAt)) || Date.parse(expiresAt) <= Date.parse(observedAt)) {
+    throw new TypeError('expiresAt must be an ISO timestamp after observedAt');
+  }
+  return { snapshotHash, observedAt, expiresAt };
+}
+
+function ingest({ payload, ...inputContext }) {
+  const { snapshotHash, observedAt, expiresAt } = context(inputContext);
+  object(payload, 'DeepSWE payload');
+  const artifact = object(payload.artifact, 'DeepSWE artifact');
+  if (artifact.owner !== OWNER || artifact.url !== ARTIFACT_URL) {
+    throw new TypeError('DeepSWE source identity does not match the owner artifact');
+  }
+  const benchmark = string(artifact.benchmark, 'DeepSWE artifact benchmark');
+  const benchmarkVersion = string(artifact.version, 'DeepSWE artifact version');
+  const harness = object(artifact.harness, 'DeepSWE artifact harness');
+  const harnessId = string(harness.id, 'DeepSWE artifact harness id');
+  const harnessVersion = string(harness.version, 'DeepSWE artifact harness version');
+  if (!Array.isArray(payload.rows)) throw new TypeError('DeepSWE rows must be an array');
+
+  const models = new Map();
+  const observations = [];
+  const observationIds = new Set();
+  payload.rows.forEach((row, index) => {
+    object(row, `DeepSWE rows[${index}]`);
+    const providerId = string(row.provider, `DeepSWE rows[${index}].provider`);
+    const modelId = string(row.model, `DeepSWE rows[${index}].model`);
+    const effort = string(row.effort, `DeepSWE rows[${index}].effort`);
+    const id = `${SOURCE_ID}:${benchmarkVersion}:${providerId}:${modelId}:${effort}`;
+    if (observationIds.has(id)) throw new TypeError(`duplicate DeepSWE observation: ${id}`);
+    observationIds.add(id);
+    models.set(`${providerId}:${modelId}`, { providerId, modelId });
+    observations.push({
+      id,
+      providerId,
+      modelId,
+      effort,
+      workload: 'development',
+      harness: { id: harnessId, version: harnessVersion },
+      score: number(row.score, `DeepSWE rows[${index}].score`),
+      source: {
+        id: SOURCE_ID,
+        owner: OWNER,
+        url: ARTIFACT_URL,
+        benchmark,
+        version: benchmarkVersion,
+        snapshotHash,
+      },
+      uncertainty: {
+        kind: 'confidence-interval-95-half-width',
+        value: number(
+          row.confidence95HalfWidth,
+          `DeepSWE rows[${index}].confidence95HalfWidth`,
+        ),
+      },
+      freshness: { observedAt, expiresAt },
+      cost: {
+        amount: number(row.averageCostUsd, `DeepSWE rows[${index}].averageCostUsd`),
+        currency: 'USD',
+        unit: 'task',
+      },
+    });
+  });
+
+  return {
+    sourceId: SOURCE_ID,
+    models: [...models.values()],
+    observations,
+  };
+}
+
+export const deepSweSource = Object.freeze({
+  sourceId: SOURCE_ID,
+  owner: OWNER,
+  artifactUrl: ARTIFACT_URL,
+  ingest,
+});

package/src/lib/routingSources/openhands.mjs

@@ -0,0 +1,102 @@
+const SOURCE_ID = 'openhands-evaluation';
+const OWNER = 'All Hands AI';
+const ARTIFACT_URL = 'https://github.com/All-Hands-AI/OpenHands/tree/main/evaluation';
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function number(value, field) {
+  if (!Number.isFinite(value)) throw new TypeError(`${field} must be a finite number`);
+  return value;
+}
+
+function ingest({ payload, snapshotHash, observedAt, expiresAt }) {
+  string(snapshotHash, 'snapshotHash');
+  if (!Number.isFinite(Date.parse(observedAt))) {
+    throw new TypeError('observedAt must be an ISO timestamp');
+  }
+  if (!Number.isFinite(Date.parse(expiresAt)) || Date.parse(expiresAt) <= Date.parse(observedAt)) {
+    throw new TypeError('expiresAt must be an ISO timestamp after observedAt');
+  }
+  object(payload, 'OpenHands payload');
+  const provenance = object(payload.provenance, 'OpenHands provenance');
+  if (provenance.organization !== OWNER || provenance.artifactUrl !== ARTIFACT_URL) {
+    throw new TypeError('OpenHands source identity does not match the owner artifact');
+  }
+  const benchmark = string(provenance.benchmarkName, 'OpenHands benchmark name');
+  const benchmarkVersion = string(
+    provenance.benchmarkVersion,
+    'OpenHands benchmark version',
+  );
+  const harnessId = string(provenance.harnessId, 'OpenHands harness id');
+  const harnessVersion = string(provenance.harnessVersion, 'OpenHands harness version');
+  if (!Array.isArray(payload.results)) throw new TypeError('OpenHands results must be an array');
+
+  const models = new Map();
+  const observations = [];
+  const observationIds = new Set();
+  payload.results.forEach((row, index) => {
+    object(row, `OpenHands results[${index}]`);
+    const providerId = string(row.provider, `OpenHands results[${index}].provider`);
+    const modelId = string(row.model, `OpenHands results[${index}].model`);
+    const effort = string(row.effort, `OpenHands results[${index}].effort`);
+    const id = `${SOURCE_ID}:${benchmarkVersion}:${providerId}:${modelId}:${effort}`;
+    if (observationIds.has(id)) throw new TypeError(`duplicate OpenHands observation: ${id}`);
+    observationIds.add(id);
+    models.set(`${providerId}:${modelId}`, { providerId, modelId });
+    const meanCost = object(row.meanCost, `OpenHands results[${index}].meanCost`);
+    observations.push({
+      id,
+      providerId,
+      modelId,
+      effort,
+      workload: 'development',
+      harness: { id: harnessId, version: harnessVersion },
+      score: number(row.resolvedRate, `OpenHands results[${index}].resolvedRate`),
+      source: {
+        id: SOURCE_ID,
+        owner: OWNER,
+        url: ARTIFACT_URL,
+        benchmark,
+        version: benchmarkVersion,
+        snapshotHash,
+      },
+      uncertainty: {
+        kind: 'standard-error',
+        value: number(row.standardError, `OpenHands results[${index}].standardError`),
+      },
+      freshness: { observedAt, expiresAt },
+      cost: {
+        amount: number(meanCost.amount, `OpenHands results[${index}].meanCost.amount`),
+        currency: string(
+          meanCost.currency,
+          `OpenHands results[${index}].meanCost.currency`,
+        ),
+        unit: string(meanCost.unit, `OpenHands results[${index}].meanCost.unit`),
+      },
+    });
+  });
+  return {
+    sourceId: SOURCE_ID,
+    models: [...models.values()],
+    observations,
+  };
+}
+
+export const openHandsSource = Object.freeze({
+  sourceId: SOURCE_ID,
+  owner: OWNER,
+  artifactUrl: ARTIFACT_URL,
+  ingest,
+});

package/src/lib/routingSources/openhandsFrontend.mjs

@@ -0,0 +1,135 @@
+import { frontendEvidenceWorkload } from '../frontendWorkloads.mjs';
+
+const OWNER_URL = 'https://www.openhands.dev/blog/openhands-index';
+const SOURCE_ID = 'openhands-frontend';
+const BENCHMARK_ID = 'swe-bench-multimodal';
+
+function object(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function finite(value, field) {
+  if (!Number.isFinite(value)) throw new TypeError(`${field} must be a finite number`);
+  return value;
+}
+
+function timestamp(value, field) {
+  string(value, field);
+  if (!Number.isFinite(Date.parse(value))) throw new TypeError(`${field} must be an ISO timestamp`);
+  return value;
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+
+function ingest({ payload, snapshotHash, observedAt, expiresAt }) {
+  object(payload, 'OpenHands frontend payload');
+  string(snapshotHash, 'snapshotHash');
+  timestamp(observedAt, 'observedAt');
+  timestamp(expiresAt, 'expiresAt');
+  if (Date.parse(expiresAt) <= Date.parse(observedAt)) {
+    throw new TypeError('expiresAt must follow observedAt');
+  }
+  if (payload.schemaVersion !== 1) throw new TypeError('OpenHands schemaVersion must be 1');
+  string(payload.exportId, 'OpenHands exportId');
+  object(payload.benchmark, 'OpenHands benchmark');
+  if (payload.benchmark.id !== BENCHMARK_ID) {
+    throw new TypeError(`OpenHands benchmark identity must be ${BENCHMARK_ID}`);
+  }
+  if (payload.benchmark.url !== OWNER_URL) {
+    throw new TypeError(`OpenHands owner URL must be ${OWNER_URL}`);
+  }
+  string(payload.benchmark.owner, 'OpenHands benchmark owner');
+  string(payload.benchmark.version, 'OpenHands benchmark version');
+  object(payload.harness, 'OpenHands harness');
+  string(payload.harness.id, 'OpenHands harness id');
+  string(payload.harness.version, 'OpenHands harness version');
+  if (!Array.isArray(payload.rows) || payload.rows.length === 0) {
+    throw new TypeError('OpenHands rows must be a non-empty array');
+  }
+
+  const models = [];
+  const observations = [];
+  const modelIds = new Set();
+  const observationIds = new Set();
+  for (const [index, row] of payload.rows.entries()) {
+    object(row, `OpenHands rows[${index}]`);
+    const providerId = string(row.providerId, `OpenHands rows[${index}].providerId`);
+    const modelId = string(row.modelId, `OpenHands rows[${index}].modelId`);
+    const effort = string(row.effort, `OpenHands rows[${index}].effort`);
+    const modelIdentity = `${providerId}:${modelId}`;
+    if (!modelIds.has(modelIdentity)) {
+      models.push({ providerId, modelId });
+      modelIds.add(modelIdentity);
+    }
+    const id = `${SOURCE_ID}:${payload.benchmark.version}:${modelIdentity}:${effort}`;
+    if (observationIds.has(id)) {
+      throw new TypeError(`duplicate observation identity: ${id}`);
+    }
+    observationIds.add(id);
+    if (!['preliminary', 'established'].includes(row.status)) {
+      throw new TypeError(`OpenHands rows[${index}].status is unsupported`);
+    }
+    object(row.cost, `OpenHands rows[${index}].cost`);
+    observations.push({
+      id,
+      providerId,
+      modelId,
+      effort,
+      workload: frontendEvidenceWorkload({
+        workload: 'frontend-repository-repair',
+        axis: 'functional',
+      }),
+      harness: {
+        id: payload.harness.id,
+        version: payload.harness.version,
+      },
+      score: finite(row.score, `OpenHands rows[${index}].score`),
+      source: {
+        id: SOURCE_ID,
+        owner: payload.benchmark.owner,
+        url: payload.benchmark.url,
+        benchmark: BENCHMARK_ID,
+        version: payload.benchmark.version,
+        snapshotHash,
+      },
+      uncertainty: {
+        kind: 'confidence-interval',
+        value: finite(
+          row.confidenceInterval,
+          `OpenHands rows[${index}].confidenceInterval`,
+        ),
+        status: row.status,
+        sampleSize: finite(row.sampleSize, `OpenHands rows[${index}].sampleSize`),
+      },
+      freshness: { observedAt, expiresAt },
+      cost: {
+        amount: finite(row.cost.amount, `OpenHands rows[${index}].cost.amount`),
+        currency: string(row.cost.currency, `OpenHands rows[${index}].cost.currency`),
+        unit: string(row.cost.unit, `OpenHands rows[${index}].cost.unit`),
+      },
+    });
+  }
+  return deepFreeze({ sourceId: SOURCE_ID, models, observations });
+}
+
+export const openHandsFrontendSource = Object.freeze({
+  sourceId: SOURCE_ID,
+  owner: 'OpenHands',
+  artifactUrl: OWNER_URL,
+  ingest,
+});