@ikon85/agent-workflow-kit 0.32.1 → 0.34.0

package/src/lib/routingProfile.mjs

@@ -0,0 +1,334 @@
+import { mkdir, open, readFile, rm } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { writeAtomic } from './atomicWrite.mjs';
+import {
+  AGENT_SURFACE_REGISTRY,
+  AGENT_SURFACE_REGISTRY_REVISION,
+  detectAgentSurfaces,
+  surfaceById,
+} from './agentSurfaceRegistry.mjs';
+
+export const ROUTING_PROFILE_VERSION = 1;
+export const ROUTING_PROFILE_PATH = 'routing-profile.json';
+
+const SWITCHING = Object.freeze(['automatic', 'ask', 'current-surface-only']);
+const ACTIVATION = Object.freeze(['approve', 'back', 'advanced', 'safe-current-surface', 'decline']);
+const PROFILE_FIELDS = new Set([
+  'schemaVersion', 'registryRevision', 'selectedSurfaces', 'consideredSurfaces',
+  'switching', 'advanced',
+]);
+
+function uniqueStrings(value, field) {
+  if (!Array.isArray(value) ||
+      !value.every((entry) => typeof entry === 'string' && entry.trim() !== '')) {
+    throw new TypeError(`${field} must be an array of non-empty strings`);
+  }
+  return [...new Set(value)];
+}
+
+export function validateRoutingProfile(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('routing profile must be an object');
+  }
+  for (const key of Object.keys(input)) {
+    if (!PROFILE_FIELDS.has(key)) throw new TypeError(`unknown routing profile field: ${key}`);
+  }
+  if (input.schemaVersion !== ROUTING_PROFILE_VERSION) {
+    throw new TypeError(`routing profile schemaVersion must be ${ROUTING_PROFILE_VERSION}`);
+  }
+  if (!Number.isInteger(input.registryRevision) || input.registryRevision < 0) {
+    throw new TypeError('routing profile registryRevision must be a non-negative integer');
+  }
+  const selectedSurfaces = uniqueStrings(input.selectedSurfaces, 'selectedSurfaces');
+  if (!selectedSurfaces.length) throw new TypeError('selectedSurfaces must not be empty');
+  const consideredSurfaces = uniqueStrings(
+    input.consideredSurfaces ?? selectedSurfaces,
+    'consideredSurfaces',
+  );
+  if (selectedSurfaces.some((id) => !consideredSurfaces.includes(id))) {
+    throw new TypeError('consideredSurfaces must include every selected surface');
+  }
+  if (!SWITCHING.includes(input.switching)) {
+    throw new TypeError(`switching must be one of: ${SWITCHING.join(', ')}`);
+  }
+  if (input.advanced !== null &&
+      (!input.advanced || typeof input.advanced !== 'object' || Array.isArray(input.advanced))) {
+    throw new TypeError('advanced must be an object or null');
+  }
+  return {
+    schemaVersion: ROUTING_PROFILE_VERSION,
+    registryRevision: input.registryRevision,
+    selectedSurfaces,
+    consideredSurfaces,
+    switching: input.switching,
+    advanced: input.advanced === null ? null : structuredClone(input.advanced),
+  };
+}
+
+export function routingProfilePath(consumerRoot, profileRoot) {
+  const root = profileRoot ??
+    join(process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state'), 'agent-workflow-kit');
+  const consumerKey = createHash('sha256').update(resolve(consumerRoot)).digest('hex').slice(0, 20);
+  return join(root, 'profiles', consumerKey, ROUTING_PROFILE_PATH);
+}
+
+async function readProfileSnapshot(consumerRoot, profileRoot) {
+  const path = routingProfilePath(consumerRoot, profileRoot);
+  try {
+    const bytes = await readFile(path, 'utf8');
+    const fingerprint = createHash('sha256').update(bytes).digest('hex');
+    try {
+      return { profile: validateRoutingProfile(JSON.parse(bytes)), fingerprint, invalid: false };
+    } catch {
+      return { profile: null, fingerprint, invalid: true };
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') return { profile: null, fingerprint: null, invalid: false };
+    throw error;
+  }
+}
+
+export async function readRoutingProfile(consumerRoot, profileRoot) {
+  const snapshot = await readProfileSnapshot(consumerRoot, profileRoot);
+  if (snapshot.invalid) throw new TypeError('routing profile is invalid');
+  return snapshot.profile;
+}
+
+async function resolvedDetectedSurfaceIds(options) {
+  if (options.detectedSurfaceIds) return uniqueStrings(options.detectedSurfaceIds, 'detectedSurfaceIds');
+  const detected = await (options.detect ?? detectAgentSurfaces)();
+  return detected.filter((surface) => surface.detected).map((surface) => surface.id);
+}
+
+export async function inspectRoutingProfile(options) {
+  const { consumerRoot, registry = AGENT_SURFACE_REGISTRY } = options;
+  const detectedSurfaceIds = await resolvedDetectedSurfaceIds(options);
+  const snapshot = await readProfileSnapshot(consumerRoot, options.profileRoot);
+  const { profile, fingerprint } = snapshot;
+  if (snapshot.invalid) {
+    return {
+      status: 'needs-reconcile',
+      reasons: ['invalid'],
+      delta: { type: 'invalid-profile' },
+      profile: null,
+      fingerprint,
+      detectedSurfaceIds,
+    };
+  }
+  if (!profile) {
+    return {
+      status: 'needs-reconcile',
+      reasons: ['missing'],
+      delta: { type: 'missing-profile' },
+      profile: null,
+      fingerprint,
+      detectedSurfaceIds,
+    };
+  }
+  const known = new Set(registry.map(({ id }) => id));
+  const considered = new Set(profile.consideredSurfaces);
+  const reasons = [];
+  const removedSurfaceIds = profile.selectedSurfaces.filter((id) => !known.has(id));
+  const newSurfaceIds = detectedSurfaceIds.filter((id) => known.has(id) && !considered.has(id));
+  if (profile.registryRevision < AGENT_SURFACE_REGISTRY_REVISION) reasons.push('materially-stale');
+  if (removedSurfaceIds.length) reasons.push('removed-route');
+  if (newSurfaceIds.length) reasons.push('new-meaningful-surface');
+  return {
+    status: reasons.length ? 'needs-reconcile' : 'still valid',
+    reasons,
+    delta: {
+      type: 'profile-delta',
+      registryRevision: {
+        from: profile.registryRevision,
+        to: AGENT_SURFACE_REGISTRY_REVISION,
+      },
+      removedSurfaces: removedSurfaceIds.map((id) => ({ id, label: id })),
+      newSurfaces: newSurfaceIds.map((id) => {
+        const surface = surfaceById(id, registry);
+        return { id, label: surface.label };
+      }),
+    },
+    profile,
+    fingerprint,
+    detectedSurfaceIds,
+  };
+}
+
+function surfaceQuestion(registry, preselected) {
+  return {
+    kind: 'surfaces',
+    message: 'Which agent apps do you use?',
+    options: registry.map(({ id, label }) => ({ id, label })),
+    preselected,
+  };
+}
+
+function autonomyQuestion() {
+  return {
+    kind: 'autonomy',
+    message: 'May the Kit switch agent apps for a task?',
+    options: [
+      { value: 'automatic', label: 'Switch automatically' },
+      { value: 'ask', label: 'Ask before switching' },
+      { value: 'current-surface-only', label: 'Stay in the current app' },
+    ],
+  };
+}
+
+export async function setupRoutingProfile(options) {
+  const {
+    consumerRoot,
+    prompt,
+    registry = AGENT_SURFACE_REGISTRY,
+  } = options;
+  if (typeof prompt !== 'function') {
+    return { status: 'needs-reconcile', reasons: ['personal-choice-required'] };
+  }
+  const detectedSurfaceIds = await resolvedDetectedSurfaceIds(options);
+  const currentSurface = options.currentSurface ?? detectedSurfaceIds[0] ?? registry[0]?.id;
+  if (!surfaceById(currentSurface, registry)) throw new TypeError('currentSurface must be registered');
+  const expectedFingerprint = options.expectedFingerprint === undefined
+    ? (await readProfileSnapshot(consumerRoot, options.profileRoot)).fingerprint
+    : options.expectedFingerprint;
+  const known = new Set(registry.map(({ id }) => id));
+  const preselected = detectedSurfaceIds.filter((id) => known.has(id));
+  if (!preselected.includes(currentSurface)) preselected.unshift(currentSurface);
+
+  while (true) {
+    const selectedSurfaces = uniqueStrings(
+      await prompt(surfaceQuestion(registry, preselected)),
+      'selected surfaces',
+    ).filter((id) => known.has(id));
+    if (!selectedSurfaces.length) selectedSurfaces.push(currentSurface);
+    let switching = selectedSurfaces.length === 1
+      ? 'current-surface-only'
+      : await prompt(autonomyQuestion());
+    if (!SWITCHING.includes(switching)) throw new TypeError('invalid autonomy choice');
+
+    let advanced = null;
+    let revisitChoices = false;
+    while (true) {
+      const summary = {
+        kind: 'activation',
+        message: 'Review routing activation',
+        selectedSurfaces,
+        switching,
+        advancedDraft: advanced,
+        actions: ACTIVATION,
+      };
+      const action = await prompt(summary);
+      if (!ACTIVATION.includes(action)) throw new TypeError('invalid activation choice');
+      if (action === 'back') {
+        revisitChoices = true;
+        break;
+      }
+      if (action === 'decline') return { status: 'declined' };
+      if (action === 'advanced') {
+        advanced = await prompt({
+          kind: 'advanced',
+          message: 'Optional model and optimization preferences',
+          draft: advanced,
+        });
+        if (!advanced || typeof advanced !== 'object' || Array.isArray(advanced)) {
+          throw new TypeError('advanced choice must be an object');
+        }
+        continue;
+      }
+      if (action === 'safe-current-surface') switching = 'current-surface-only';
+      const profile = validateRoutingProfile({
+        schemaVersion: ROUTING_PROFILE_VERSION,
+        registryRevision: AGENT_SURFACE_REGISTRY_REVISION,
+        selectedSurfaces,
+        consideredSurfaces: [...new Set([...preselected, ...selectedSurfaces])],
+        switching,
+        advanced,
+      });
+      await writeProfileExpected(options, profile, expectedFingerprint);
+      return { status: 'activated', profile };
+    }
+    if (revisitChoices) continue;
+  }
+}
+
+export async function reconcileRoutingProfile(options, inspection) {
+  if (inspection.status === 'still valid') return { status: 'still valid' };
+  if (typeof options.prompt !== 'function') {
+    return { status: 'needs-reconcile', reasons: inspection.reasons };
+  }
+  const choice = await options.prompt({
+    kind: 'reconcile',
+    message: 'Your routing choices need review.',
+    reasons: inspection.reasons,
+    delta: inspection.delta,
+    actions: ['review', 'decline'],
+  });
+  if (choice === 'decline' || choice?.action === 'decline') {
+    return { status: 'declined', reasons: inspection.reasons };
+  }
+  if (!inspection.profile) {
+    if (choice !== 'review' && choice?.action !== 'review') {
+      return { status: 'declined', reasons: inspection.reasons };
+    }
+    return setupRoutingProfile({ ...options, expectedFingerprint: inspection.fingerprint });
+  }
+  if (choice !== 'apply' && choice?.action !== 'apply') {
+    return { status: 'declined', reasons: inspection.reasons };
+  }
+
+  const removed = new Set(inspection.delta.removedSurfaces.map(({ id }) => id));
+  const requestedAdds = new Set(choice.addSurfaceIds ?? []);
+  const knownAdds = inspection.delta.newSurfaces
+    .map(({ id }) => id)
+    .filter((id) => requestedAdds.has(id));
+  const selectedSurfaces = [
+    ...inspection.profile.selectedSurfaces.filter((id) => !removed.has(id)),
+    ...knownAdds,
+  ];
+  let switching = inspection.profile.switching;
+  if (!selectedSurfaces.length) {
+    const safeSurface = options.currentSurface ??
+      inspection.detectedSurfaceIds[0] ??
+      AGENT_SURFACE_REGISTRY[0].id;
+    selectedSurfaces.push(safeSurface);
+    switching = 'current-surface-only';
+  }
+  const profile = validateRoutingProfile({
+    ...inspection.profile,
+    registryRevision: AGENT_SURFACE_REGISTRY_REVISION,
+    selectedSurfaces,
+    consideredSurfaces: [
+      ...inspection.profile.consideredSurfaces.filter((id) => !removed.has(id)),
+      ...inspection.delta.newSurfaces.map(({ id }) => id),
+    ],
+    switching,
+  });
+  await writeProfileExpected(options, profile, inspection.fingerprint);
+  return { status: 'reconciled', reasons: inspection.reasons, profile };
+}
+
+async function writeProfileExpected(options, profile, expectedFingerprint) {
+  const path = routingProfilePath(options.consumerRoot, options.profileRoot);
+  const lockPath = `${path}.lock`;
+  await mkdir(dirname(path), { recursive: true });
+  let lock;
+  try {
+    lock = await open(lockPath, 'wx');
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      throw new Error('concurrent routing profile mutation: profile lock is held');
+    }
+    throw error;
+  }
+  try {
+    const actual = (await readProfileSnapshot(options.consumerRoot, options.profileRoot)).fingerprint;
+    if (actual !== expectedFingerprint) {
+      throw new Error('concurrent routing profile mutation: profile changed during decision');
+    }
+    await writeAtomic(path, `${JSON.stringify(profile, null, 2)}\n`);
+  } finally {
+    await lock.close();
+    await rm(lockPath, { force: true });
+  }
+}

package/src/lib/routingResolver.mjs

@@ -0,0 +1,176 @@
+import {
+  evidenceSelectionMatchesObservation,
+  validateRoutingIntent,
+} from './routingIntent.mjs';
+import { validateEvidenceCatalog } from './routingCatalog.mjs';
+import { validateAccessGraph } from './routingAccessGraph.mjs';
+import { validateRoutingPolicy } from './routingPolicy.mjs';
+
+export const ROUTE_DECISION_VERSION = 1;
+
+const REQUIRED_INFRASTRUCTURE = ['catalog', 'accessGraph', 'policy'];
+
+function missingDecision(missing, explicitFallback) {
+  return Object.freeze({
+    schemaVersion: ROUTE_DECISION_VERSION,
+    status: explicitFallback === 'inherit' ? 'inherit' : 'blocked',
+    reason: 'routing-infrastructure-missing',
+    missing: Object.freeze(missing),
+    bestOverall: null,
+    bestExecutable: null,
+    blockers: Object.freeze(missing.map((field) => `missing:${field}`)),
+    revisions: Object.freeze({ catalog: null, accessGraph: null, policy: null }),
+  });
+}
+
+function compareCandidates(optimization) {
+  return (left, right) => {
+    if (optimization === 'cost') {
+      return left.cost.amount - right.cost.amount || right.score - left.score;
+    }
+    if (optimization === 'balanced') {
+      const leftValue = left.score / (1 + left.cost.amount);
+      const rightValue = right.score / (1 + right.cost.amount);
+      return rightValue - leftValue || right.score - left.score;
+    }
+    return right.score - left.score || left.cost.amount - right.cost.amount;
+  };
+}
+
+function observationRoute(observation) {
+  return Object.freeze({
+    observationId: observation.id,
+    providerId: observation.providerId,
+    modelId: observation.modelId,
+    effort: observation.effort,
+    workload: observation.workload,
+    harness: observation.harness,
+    score: observation.score,
+    source: observation.source,
+    uncertainty: observation.uncertainty,
+    freshness: observation.freshness,
+    cost: observation.cost,
+    reason: `${observation.workload} supported by ${observation.source.id}`,
+  });
+}
+
+function executableRoute(observation, path) {
+  return Object.freeze({
+    ...observationRoute(observation),
+    accessPathId: path.id,
+    surfaceId: path.surfaceId,
+    transportId: path.transportId,
+    enforcement: path.enforcement,
+    capabilityEvidence: path.capabilityEvidence,
+  });
+}
+
+function pathAllowed(path, policy, activeSurface, knownTransports, now, blockers) {
+  if (!knownTransports.has(path.transportId)) {
+    blockers.add(`unknown-transport:${path.transportId}`);
+    return false;
+  }
+  if (Date.parse(path.capabilityEvidence.expiresAt) <= now) {
+    blockers.add(`stale-capability-evidence:${path.id}`);
+    return false;
+  }
+  if (path.availability !== 'available') {
+    blockers.add(`route-${path.availability}:${path.id}`);
+    return false;
+  }
+  if (!policy.allowedSurfaces.includes(path.surfaceId)) {
+    blockers.add(`surface-not-allowed:${path.surfaceId}`);
+    return false;
+  }
+  if (!policy.allowedTransports.includes(path.transportId)) {
+    blockers.add(`transport-not-allowed:${path.transportId}`);
+    return false;
+  }
+  if (path.surfaceId !== activeSurface) {
+    if (policy.switching === 'current-surface-only') {
+      blockers.add(`surface-switch-disabled:${path.surfaceId}`);
+      return false;
+    }
+    if (policy.switching === 'ask') {
+      blockers.add(`surface-switch-approval-required:${path.surfaceId}`);
+      return false;
+    }
+  }
+  return true;
+}
+
+function noExecutableStatus(policy) {
+  if (policy.unreachable === 'inherit') return 'inherit';
+  if (policy.unreachable === 'handoff') return 'handoff';
+  return 'blocked';
+}
+
+export function resolveRoute(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('route resolution input must be an object');
+  }
+  const missing = REQUIRED_INFRASTRUCTURE.filter((field) => input[field] == null);
+  if (missing.length > 0) return missingDecision(missing, input.missingInfrastructure);
+
+  const intent = validateRoutingIntent(input.intent);
+  const catalog = validateEvidenceCatalog(input.catalog);
+  const accessGraph = validateAccessGraph(input.accessGraph);
+  const policy = validateRoutingPolicy(input.policy);
+  if (typeof input.activeSurface !== 'string' || input.activeSurface === '') {
+    throw new TypeError('activeSurface must be a non-empty string');
+  }
+  if (!Array.isArray(input.knownTransports)
+      || !input.knownTransports.every((entry) => typeof entry === 'string' && entry !== '')) {
+    throw new TypeError('knownTransports must be an array of non-empty strings');
+  }
+  const now = Date.parse(input.now);
+  if (!Number.isFinite(now)) throw new TypeError('now must be an ISO timestamp');
+
+  const blockers = new Set();
+  const currentEvidence = catalog.observations.filter((entry) => {
+    const matchesIntent = intent.evidenceSelection
+      ? evidenceSelectionMatchesObservation(intent.evidenceSelection, entry.workload)
+      : entry.workload === intent.workload;
+    if (!matchesIntent) return false;
+    if (Date.parse(entry.freshness.expiresAt) <= now) {
+      blockers.add(`stale-catalog-evidence:${entry.id}`);
+      return false;
+    }
+    return true;
+  });
+  const rankedOverall = [...currentEvidence].sort(compareCandidates(policy.optimization));
+  const bestOverall = rankedOverall.length > 0 ? observationRoute(rankedOverall[0]) : null;
+
+  const knownTransports = new Set(input.knownTransports);
+  const executable = [];
+  for (const evidence of currentEvidence) {
+    for (const path of accessGraph.paths) {
+      if (path.providerId !== evidence.providerId || path.modelId !== evidence.modelId) continue;
+      if (!pathAllowed(path, policy, input.activeSurface, knownTransports, now, blockers)) continue;
+      executable.push({ evidence, path });
+    }
+  }
+  executable.sort((left, right) =>
+    compareCandidates(policy.optimization)(left.evidence, right.evidence)
+      || Number(right.path.surfaceId === input.activeSurface)
+        - Number(left.path.surfaceId === input.activeSurface)
+      || left.path.id.localeCompare(right.path.id));
+  const bestExecutable = executable.length > 0
+    ? executableRoute(executable[0].evidence, executable[0].path)
+    : null;
+  const status = bestExecutable ? 'ready' : noExecutableStatus(policy);
+  return Object.freeze({
+    schemaVersion: ROUTE_DECISION_VERSION,
+    status,
+    reason: bestExecutable ? 'route-resolved' : 'no-executable-route',
+    intent,
+    bestOverall,
+    bestExecutable,
+    blockers: Object.freeze([...blockers].sort()),
+    revisions: Object.freeze({
+      catalog: catalog.revision,
+      accessGraph: accessGraph.revision,
+      policy: policy.revision,
+    }),
+  });
+}

package/src/lib/routingSources/artificialAnalysis.mjs

@@ -0,0 +1,129 @@
+const SOURCE_ID = 'artificial-analysis-coding-agents';
+const OWNER = 'Artificial Analysis';
+const ARTIFACT_URL = 'https://artificialanalysis.ai/agents/coding-agents';
+
+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, 'Artificial Analysis payload');
+  const identity = object(payload.identity, 'Artificial Analysis identity');
+  if (identity.publisher !== OWNER || identity.canonicalUrl !== ARTIFACT_URL) {
+    throw new TypeError(
+      'Artificial Analysis source identity does not match the owner artifact',
+    );
+  }
+  const benchmark = string(identity.index, 'Artificial Analysis index');
+  const benchmarkVersion = string(identity.release, 'Artificial Analysis release');
+  const harnessId = string(identity.harnessName, 'Artificial Analysis harness name');
+  const harnessVersion = string(
+    identity.harnessRelease,
+    'Artificial Analysis harness release',
+  );
+  if (!Array.isArray(payload.configurations)) {
+    throw new TypeError('Artificial Analysis configurations must be an array');
+  }
+
+  const models = new Map();
+  const observations = [];
+  const observationIds = new Set();
+  payload.configurations.forEach((row, index) => {
+    object(row, `Artificial Analysis configurations[${index}]`);
+    const providerId = string(
+      row.providerId,
+      `Artificial Analysis configurations[${index}].providerId`,
+    );
+    const modelId = string(
+      row.modelId,
+      `Artificial Analysis configurations[${index}].modelId`,
+    );
+    const effort = string(
+      row.reasoningEffort,
+      `Artificial Analysis configurations[${index}].effort`,
+    );
+    const id = `${SOURCE_ID}:${benchmarkVersion}:${providerId}:${modelId}:${effort}`;
+    if (observationIds.has(id)) {
+      throw new TypeError(`duplicate Artificial Analysis observation: ${id}`);
+    }
+    observationIds.add(id);
+    models.set(`${providerId}:${modelId}`, { providerId, modelId });
+    const uncertainty = object(
+      row.uncertainty,
+      `Artificial Analysis configurations[${index}].uncertainty`,
+    );
+    observations.push({
+      id,
+      providerId,
+      modelId,
+      effort,
+      workload: 'development',
+      harness: { id: harnessId, version: harnessVersion },
+      score: number(
+        row.indexScore,
+        `Artificial Analysis configurations[${index}].indexScore`,
+      ),
+      source: {
+        id: SOURCE_ID,
+        owner: OWNER,
+        url: ARTIFACT_URL,
+        benchmark,
+        version: benchmarkVersion,
+        snapshotHash,
+      },
+      uncertainty: {
+        kind: string(
+          uncertainty.kind,
+          `Artificial Analysis configurations[${index}].uncertainty.kind`,
+        ),
+        value: number(
+          uncertainty.value,
+          `Artificial Analysis configurations[${index}].uncertainty.value`,
+        ),
+      },
+      freshness: { observedAt, expiresAt },
+      cost: {
+        amount: number(
+          row.costPerTaskUsd,
+          `Artificial Analysis configurations[${index}].costPerTaskUsd`,
+        ),
+        currency: 'USD',
+        unit: 'task',
+      },
+    });
+  });
+  return {
+    sourceId: SOURCE_ID,
+    models: [...models.values()],
+    observations,
+  };
+}
+
+export const artificialAnalysisSource = Object.freeze({
+  sourceId: SOURCE_ID,
+  owner: OWNER,
+  artifactUrl: ARTIFACT_URL,
+  ingest,
+});