| import { createHash } from 'node:crypto'; |
| import { readFileSync } from 'node:fs'; |
| import { MODEL_CHECK_DETAILS, MODEL_MISSING_OBSERVATIONS, ModelCatalogSchema, ModelRequestSchema, ModelResultSchema, ModelSequenceSchema, ModelSnapshotSchema, type ModelRequest, type ModelResult, type ModelSnapshot } from '@her2/shared'; |
| import { z } from 'zod'; |
| import { ApiFailure } from './errors.js'; |
|
|
| const hash = (text: string) => createHash('sha256').update(text).digest('hex'); |
| const observationText = readFileSync(new URL('../../../data/model_observations.json', import.meta.url), 'utf8'); |
| const sequenceText = readFileSync(new URL('../../../data/antibody_embeddings.json', import.meta.url), 'utf8'); |
| const snapshot = ModelSnapshotSchema.parse(JSON.parse(observationText)); |
| const metadataText = readFileSync(new URL('../../../data/model_sources/her2_alphafold_metadata.json', import.meta.url), 'utf8'); |
| const confidenceText = readFileSync(new URL('../../../data/model_sources/her2_alphafold_confidence.json', import.meta.url), 'utf8'); |
| verifyModelSources(snapshot, metadataText, confidenceText); |
| const sequence = z.object({ |
| model: z.object({ id: z.literal('facebook/esm2_t33_650M_UR50D'), revision: z.literal('08e4846e537177426273712802403f7ba8261b6c') }), |
| generated_at: z.string(), sequence_source: z.object({ sha256: z.string().regex(/^[a-f0-9]{64}$/) }), |
| records: z.array(z.object({ id: z.string(), therasabdab_name: z.string(), input_sequence_sha256: z.string().regex(/^[a-f0-9]{64}$/) })).length(29), |
| cosine: z.array(z.array(z.number().finite().min(-1).max(1)).length(29)).length(29), |
| identity: z.array(z.array(z.number().finite().min(0).max(1)).length(29)).length(29) |
| }).parse(JSON.parse(sequenceText)); |
| export const MODEL_SNAPSHOT_SHA256 = hash(observationText); |
| const sequenceSha = hash(sequenceText); |
| const codeSha = hash(['./models.ts', './models-routes.ts', '../../../packages/shared/src/models.ts', '../../../scripts/score_models.py'].map(path => readFileSync(new URL(path, import.meta.url), 'utf8')).join('\n')); |
|
|
| export function verifyModelSources(observations: ModelSnapshot, metadataRaw: string, confidenceRaw: string) { |
| const confidence = z.object({ confidenceScore: z.array(z.number().finite()).length(1255) }).parse(JSON.parse(confidenceRaw)); |
| const metadata = z.array(z.object({ entryId: z.string(), uniprotAccession: z.string(), latestVersion: z.number(), |
| sequence: z.string(), modelCreatedDate: z.string(), toolUsed: z.string(), isComplex: z.boolean(), plddtDocUrl: z.string() })).parse(JSON.parse(metadataRaw)); |
| const entries = metadata.filter(r => r.entryId === observations.structure.entry_id && r.uniprotAccession === 'P04626' && r.latestVersion === 6); |
| const entry = entries[0]; |
| if (hash(metadataRaw) !== observations.structure.metadata_sha256 || hash(confidenceRaw) !== observations.structure.confidence_sha256 |
| || JSON.stringify(confidence.confidenceScore) !== JSON.stringify(observations.structure.plddt) || entries.length !== 1 || !entry |
| || entry.isComplex || entry.sequence.length !== 1255 || hash(entry.sequence) !== observations.structure.sequence_sha256 |
| || entry.modelCreatedDate !== observations.structure.model_created_at || entry.toolUsed !== observations.structure.method |
| || entry.plddtDocUrl !== observations.structure.confidence_url) throw new ApiFailure('MODEL_ARTIFACT_INVALID', 500); |
| } |
|
|
| export function buildModelCatalog() { |
| return ModelCatalogSchema.parse({ |
| snapshot, snapshot_sha256: MODEL_SNAPSHOT_SHA256, |
| code_sha256: codeSha, sequence_artifact_sha256: sequenceSha, |
| sequences: { DRG0CYMEB: sequenceObservation('DRG0CYMEB'), DRG0ERKBH: sequenceObservation('DRG0ERKBH') }, |
| products: [{ id: 'DRG0CYMEB', name: 'Kadcyla' }, { id: 'DRG0ERKBH', name: 'Enhertu' }], |
| unavailable: [ |
| { name: 'OpenFold / ESMFold', reason: 'Not run. No hosted folding provider or safe local folding checkpoint was verified.', url: 'https://openfold.readthedocs.io/en/latest/Inference.html' }, |
| { name: 'AlphaFold 3', reason: 'Not connected. Requires separate access, terms and compute; target metadata below is AlphaFold DB, not AF3.', url: 'https://github.com/google-deepmind/alphafold3' }, |
| { name: 'AlphaGenome', reason: 'Not run. Regulatory-variant models do not score ADC linker chemistry.', url: 'https://www.alphagenomedocs.com/' }, |
| { name: 'Antigravity Science skills', reason: 'Reviewed as engineering tools. Their presence is not a model execution.', url: 'https://github.com/google-deepmind/science-skills' } |
| ] |
| }); |
| } |
|
|
| export function runModels(input: unknown): ModelResult { |
| const parsed = ModelRequestSchema.safeParse(input); |
| if (!parsed.success) throw new ApiFailure('INVALID_REQUEST', 400); |
| const request = parsed.data; |
| const molecule = snapshot.molecules.find(m => m.id === request.molecule_id); |
| if (!molecule) throw new ApiFailure('INVALID_REQUEST', 400); |
| const useSequence = request.observation_policy === 'all' || request.observation_policy === 'without_structure'; |
| const useStructure = request.observation_policy === 'all' || request.observation_policy === 'without_sequence'; |
| const missing: string[] = [...MODEL_MISSING_OBSERVATIONS]; |
| if (!useSequence) missing.push('Sequence observation withheld.'); |
| if (!useStructure) missing.push('Target structure observation withheld.'); |
| return ModelResultSchema.parse({ |
| version: 'conjugate-models-1', request, snapshot_sha256: MODEL_SNAPSHOT_SHA256, |
| sequence_artifact_sha256: sequenceSha, code_sha256: codeSha, execution: 'frozen_observations', model_calls: 0, |
| molecule, |
| sequence: useSequence ? sequenceObservation(request.product_id) : null, |
| structure: useStructure ? snapshot.structure : null, |
| checks: [ |
| { id: 'valid_smiles', passed: molecule.valid, detail: MODEL_CHECK_DETAILS.valid_smiles }, |
| { id: 'connected', passed: molecule.connected, detail: MODEL_CHECK_DETAILS.connected }, |
| { id: 'two_attachments', passed: molecule.has_two_mapped_attachments, detail: MODEL_CHECK_DETAILS.two_attachments } |
| ], |
| missing, overall_adc_score: null, clinical_status: 'draft_pending_pharmacist', eligibility: 'not_assessed', |
| needs_human: true, guardrail: { status: 'blocked' }, answer_correctness_probability: null, omission_probability: null |
| }); |
| } |
|
|
| function sequenceObservation(product: ModelRequest['product_id']) { |
| const row = sequence.records.findIndex(r => r.id === product && r.therasabdab_name === 'Trastuzumab'); |
| const reference = sequence.records.findIndex(r => r.id === 'DRG0CYMEB' && r.therasabdab_name === 'Trastuzumab'); |
| if (row < 0 || reference < 0) throw new ApiFailure('MODEL_ARTIFACT_INVALID', 500); |
| return ModelSequenceSchema.parse({ |
| model_id: sequence.model.id, revision: sequence.model.revision, generated_at: sequence.generated_at, |
| source_sha256: sequence.sequence_source.sha256, input_sequence_sha256: sequence.records[row]?.input_sequence_sha256, |
| reference_product_id: 'DRG0CYMEB', antibody: 'Trastuzumab', cosine: sequence.cosine[row]?.[reference], identity: sequence.identity[row]?.[reference] |
| }); |
| } |
|
|
| function canonical(value: unknown): string { |
| if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`; |
| if (value !== null && typeof value === 'object') return `{${Object.keys(value).sort().map(k => `${JSON.stringify(k)}:${canonical((value as Record<string, unknown>)[k])}`).join(',')}}`; |
| return JSON.stringify(value); |
| } |
|
|
| export function replayModels(input: unknown) { |
| const parsed = ModelResultSchema.safeParse(input); |
| if (!parsed.success || canonical(parsed.data) !== canonical(runModels(parsed.data.request))) { |
| throw new ApiFailure('MODEL_REPLAY_REJECTED', 400); |
| } |
| return { verified: true as const, snapshot_sha256: MODEL_SNAPSHOT_SHA256, scope: 'Artifact consistency only; model inference was not repeated.' }; |
| } |
|
|
