playwright-intelligence-engine 0.0.0-stage → 2.0.1

package/src/intelligence/llm-proposal.ts

@@ -0,0 +1,519 @@
+import { z } from 'zod';
+import { RepairOperation, RepairOperationSchema, validateRepairOperation } from '../repair/repair-operations.js';
+
+export const EvidenceBundleSchema = z.object({
+  bundleId: z.string().min(1),
+  executionId: z.string().min(1),
+  testIdentity: z.string().min(1),
+  failedActionId: z.string().optional(),
+  failureCategory: z.string().optional(),
+  sourceContext: z.array(z.object({
+    filePath: z.string(),
+    startLine: z.number().int().positive().optional(),
+    endLine: z.number().int().positive().optional(),
+    content: z.string(),
+  })).default([]),
+  artifacts: z.array(z.object({
+    kind: z.enum(['trace', 'screenshot', 'dom', 'aria', 'network', 'console', 'video', 'git-diff']),
+    reference: z.string(),
+    redacted: z.boolean(),
+  })).default([]),
+  diagnostic: z.object({
+    playwrightVersion: z.string(),
+    traceFormatVersion: z.number(),
+    failedAction: z.object({
+      callId: z.string(),
+      action: z.string(),
+      selector: z.string().optional(),
+      sourceFile: z.string().optional(),
+      line: z.number().optional(),
+      column: z.number().optional(),
+      errorMessage: z.string().optional(),
+      errorStack: z.string().optional(),
+      durationMs: z.number().optional(),
+      logs: z.array(z.string()).optional(),
+    }),
+    snapshots: z.object({
+      before: z.string().optional(),
+      action: z.string().optional(),
+      after: z.string().optional(),
+    }),
+    networkEvents: z.array(z.object({
+      method: z.string(),
+      url: z.string(),
+      status: z.number(),
+      statusText: z.string().optional(),
+      errorText: z.string().optional(),
+    })),
+    consoleEvents: z.array(z.object({ type: z.string(), text: z.string() })),
+    evidenceCompleteness: z.object({
+      domAvailable: z.boolean(),
+      networkAvailable: z.boolean(),
+      sourceAvailable: z.boolean(),
+    }),
+  }).optional(),
+  redactionComplete: z.boolean(),
+  limitations: z.array(z.string()).default([]),
+}).strict();
+
+export type EvidenceBundle = z.infer<typeof EvidenceBundleSchema>;
+
+export const LlmRepairProposalSchema = z.object({
+  proposalVersion: z.literal('1'),
+  decision: z.enum(['PROPOSE', 'ABSTAIN']),
+  failureKind: z.string().min(1),
+  confidence: z.number().min(0).max(1),
+  reasoningSummary: z.string().min(1),
+  operations: z.array(RepairOperationSchema).max(20),
+  requiredVerification: z.array(z.string()).min(1),
+  evidenceReferences: z.array(z.string()),
+}).strict();
+
+export type LlmRepairProposal = z.infer<typeof LlmRepairProposalSchema>;
+
+export interface ProposalParseResult {
+  isValid: boolean;
+  proposal?: LlmRepairProposal;
+  errors: string[];
+  normalizationNotes?: string[] | undefined;
+}
+
+export const AgentActionKindSchema = z.enum([
+  'inspect_evidence',
+  'inspect_browser_state',
+  'inspect_repository',
+  'read_source_file',
+  'search_repository',
+  'discover_source_mapping',
+  'rank_locator_candidates',
+  'build_repair_proposal',
+  'run_target_test',
+  'verify_repair',
+  'abstain',
+]);
+
+export type AgentActionKind = z.infer<typeof AgentActionKindSchema>;
+
+export const AgentActionSchema = z.object({
+  kind: AgentActionKindSchema,
+  selector: z.string().min(1).optional(),
+  target: z.string().min(1).optional(),
+  locator: z.string().min(1).optional(),
+  path: z.string().min(1).optional(),
+  query: z.string().min(1).optional(),
+  testFile: z.string().min(1).optional(),
+  configPath: z.string().min(1).optional(),
+  sourceFile: z.string().min(1).optional(),
+  className: z.string().min(1).optional(),
+  memberName: z.string().min(1).optional(),
+  reason: z.string().min(1).optional(),
+}).strict();
+
+export type AgentAction = z.infer<typeof AgentActionSchema>;
+
+const AgentClassificationSchema = z.object({
+  category: z.string().min(1),
+  confidence: z.number().min(0).max(1),
+}).strict();
+
+const AgentStepResponseSchema = z.object({
+  protocolVersion: z.literal('2'),
+  responseType: z.literal('STEP'),
+  status: z.literal('CONTINUE'),
+  decision: z.enum([
+    'INSPECT_EVIDENCE',
+    'INSPECT_BROWSER_STATE',
+    'INSPECT_REPOSITORY',
+    'READ_SOURCE_FILE',
+    'SEARCH_REPOSITORY',
+    'DISCOVER_SOURCE_MAPPING',
+    'RANK_LOCATOR_CANDIDATES',
+    'BUILD_REPAIR_PROPOSAL',
+    'RUN_TARGET_TEST',
+    'VERIFY_REPAIR',
+    'ABSTAIN',
+  ]),
+  confidence: z.number().min(0).max(1),
+  reasoningSummary: z.string().min(1),
+  evidenceReferences: z.array(z.string()),
+  action: AgentActionSchema,
+  requiredObservation: z.string().min(1),
+}).strict();
+
+const AgentFinalResponseSchema = z.object({
+  protocolVersion: z.literal('2'),
+  responseType: z.literal('FINAL'),
+  status: z.enum(['PROPOSAL_READY', 'VERIFIED_READY_FOR_APPROVAL', 'ABSTAIN', 'BLOCKED', 'REJECTED']),
+  classification: AgentClassificationSchema,
+  reasoningSummary: z.string().min(1),
+  evidenceReferences: z.array(z.string()),
+  proposal: LlmRepairProposalSchema.optional(),
+  verification: z.object({
+    isolatedTestPassed: z.boolean().optional(),
+    assertionsChanged: z.boolean().optional(),
+    unrelatedFilesChanged: z.boolean().optional(),
+  }).strict().optional(),
+  humanApprovalRequired: z.boolean(),
+}).strict();
+
+export const AgentResponseSchema = z.discriminatedUnion('responseType', [AgentStepResponseSchema, AgentFinalResponseSchema]);
+
+export type AgentStepResponse = z.infer<typeof AgentStepResponseSchema>;
+export type AgentFinalResponse = z.infer<typeof AgentFinalResponseSchema>;
+export type AgentResponse = z.infer<typeof AgentResponseSchema>;
+
+export interface AgentResponseParseResult {
+  isValid: boolean;
+  response?: AgentResponse;
+  errors: string[];
+  normalizationNotes?: string[] | undefined;
+  /** Recognized transport metadata removed before strict protocol validation. */
+  protocolMetadata?: AgentProtocolMetadata | undefined;
+}
+
+export interface AgentProtocolMetadata {
+  callId?: string | undefined;
+  requestId?: string | undefined;
+  responseId?: string | undefined;
+  messageId?: string | undefined;
+  model?: string | undefined;
+  provider?: string | undefined;
+  finishReason?: string | undefined;
+  usage?: unknown;
+}
+
+function extractJsonCandidate(input: string): string {
+  const trimmed = input.trim();
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fenced?.[1]) return fenced[1].trim();
+  const start = trimmed.indexOf('{');
+  const end = trimmed.lastIndexOf('}');
+  return start >= 0 && end > start ? trimmed.slice(start, end + 1) : trimmed;
+}
+
+function parseJsonInput(input: unknown): { candidate?: unknown; errors: string[] } {
+  if (typeof input !== 'string') return { candidate: input, errors: [] };
+  try {
+    return { candidate: JSON.parse(extractJsonCandidate(input)), errors: [] };
+  } catch (error) {
+    return { errors: [`Response is not valid JSON: ${String(error)}`] };
+  }
+}
+
+function normalizeAgentCandidate(input: unknown): { candidate: unknown; notes: string[]; metadata?: AgentProtocolMetadata | undefined } {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return { candidate: input, notes: [] };
+  const envelope = normalizeAgentEnvelope(input as Record<string, unknown>);
+  const source = envelope.candidate as Record<string, unknown>;
+  const withEnvelope = (candidate: unknown, notes: string[] = []) => ({
+    candidate,
+    notes: [...envelope.notes, ...notes],
+    ...(envelope.metadata ? { metadata: envelope.metadata } : {}),
+  });
+  if (source.responseType === 'FINAL') {
+    const allowedFinalKeys = new Set([
+      'protocolVersion', 'responseType', 'status', 'classification',
+      'reasoningSummary', 'evidenceReferences', 'proposal', 'verification',
+      'humanApprovalRequired',
+    ]);
+    if (Object.keys(source).some((key) => !allowedFinalKeys.has(key))) return withEnvelope(source);
+    // Accept a complete PIE final response unchanged. Compatibility handling
+    // below is deliberately limited to documented sparse-final variants.
+    if (AgentFinalResponseSchema.safeParse(source).success) return withEnvelope(source);
+
+    const notes: string[] = [];
+    const classification = source.classification && typeof source.classification === 'object' && !Array.isArray(source.classification)
+      ? source.classification as Record<string, unknown>
+      : {};
+    const normalizedClassification = typeof classification.category === 'string'
+      && typeof classification.confidence === 'number'
+      && classification.confidence >= 0
+      && classification.confidence <= 1
+      ? { category: classification.category, confidence: classification.confidence }
+      : { category: 'MODEL_RESPONSE', confidence: 0 };
+    const evidenceReferences = Array.isArray(source.evidenceReferences)
+      ? source.evidenceReferences.filter((value): value is string => typeof value === 'string')
+      : [];
+    const reasoningSummary = typeof source.reasoningSummary === 'string'
+      ? source.reasoningSummary
+      : 'The model returned an incomplete final response.';
+    const humanApprovalRequired = typeof source.humanApprovalRequired === 'boolean' ? source.humanApprovalRequired : true;
+
+    if (source.status === 'ABSTAIN') {
+      notes.push('Normalized sparse FINAL ABSTAIN response with conservative classification and approval defaults.');
+      return withEnvelope({
+          protocolVersion: '2',
+          responseType: 'FINAL',
+          status: 'ABSTAIN',
+          classification: normalizedClassification,
+          reasoningSummary,
+          evidenceReferences,
+          humanApprovalRequired,
+        }, notes);
+    }
+
+    if (source.status === 'PROPOSAL' && source.proposal && typeof source.proposal === 'object' && !Array.isArray(source.proposal)) {
+      const legacyProposal = source.proposal as Record<string, unknown>;
+      const target = legacyProposal.target;
+      const locator = legacyProposal.locator;
+      if (target && typeof target === 'object' && !Array.isArray(target)
+        && typeof (target as Record<string, unknown>).filePath === 'string'
+        && typeof locator === 'string' && locator.length > 0) {
+        notes.push('Mapped recognized legacy FINAL PROPOSAL shape to BLOCKED because it lacks a safe old-locator operation.');
+        return withEnvelope({
+            protocolVersion: '2',
+            responseType: 'FINAL',
+            status: 'BLOCKED',
+            classification: normalizedClassification,
+            reasoningSummary: 'The model returned a source-location proposal without a complete PIE repair operation; no mutation was synthesized.',
+            evidenceReferences,
+            humanApprovalRequired: true,
+          }, notes);
+      }
+    }
+
+    const legacyFinalStatuses = new Set(['OK', 'PROPOSED', 'PROPOSAL_ONLY', 'REPAIR_PROPOSAL', 'COMPLETE']);
+    if (typeof source.status === 'string' && legacyFinalStatuses.has(source.status)
+      && source.proposal && typeof source.proposal === 'object' && !Array.isArray(source.proposal)) {
+      const legacyProposal = source.proposal as Record<string, unknown>;
+      const failureCategory = typeof legacyProposal.failureCategory === 'string'
+        ? legacyProposal.failureCategory.trim().toUpperCase()
+        : typeof legacyProposal.failureKind === 'string'
+          ? legacyProposal.failureKind.trim().toUpperCase()
+          : typeof legacyProposal.category === 'string'
+            ? legacyProposal.category.trim().toUpperCase()
+            : undefined;
+      const confidence = typeof legacyProposal.confidence === 'number' && legacyProposal.confidence >= 0 && legacyProposal.confidence <= 1
+        ? legacyProposal.confidence
+        : 0;
+      const summary = typeof legacyProposal.summary === 'string'
+        ? legacyProposal.summary
+        : typeof legacyProposal.rationale === 'string'
+          ? legacyProposal.rationale
+          : 'The model returned a legacy locator proposal.';
+      const directTarget = typeof legacyProposal.oldLocator === 'string' ? legacyProposal.oldLocator
+        : typeof legacyProposal.oldText === 'string' ? legacyProposal.oldText
+          : typeof legacyProposal.originalLocator === 'string' ? legacyProposal.originalLocator : undefined;
+      const directLocator = typeof legacyProposal.newLocator === 'string' ? legacyProposal.newLocator
+        : typeof legacyProposal.newText === 'string' ? legacyProposal.newText
+          : typeof legacyProposal.proposedLocator === 'string' ? legacyProposal.proposedLocator : undefined;
+      const edits = Array.isArray(legacyProposal.edits) ? legacyProposal.edits : Array.isArray(legacyProposal.changes) ? legacyProposal.changes : [];
+      const firstEdit = edits[0] && typeof edits[0] === 'object' && !Array.isArray(edits[0]) ? edits[0] as Record<string, unknown> : {};
+      const target = directTarget
+        ?? (typeof firstEdit.oldLocator === 'string' ? firstEdit.oldLocator : typeof firstEdit.oldText === 'string' ? firstEdit.oldText : undefined)
+        ?? (typeof legacyProposal.target === 'string' ? legacyProposal.target : undefined);
+      const locator = directLocator
+        ?? (typeof firstEdit.newLocator === 'string' ? firstEdit.newLocator : typeof firstEdit.newText === 'string' ? firstEdit.newText : undefined)
+        ?? (typeof legacyProposal.locator === 'string' ? legacyProposal.locator : undefined);
+      const hasLegacyLocatorShape = typeof target === 'string'
+        || typeof locator === 'string'
+        || typeof legacyProposal.target === 'string'
+        || typeof legacyProposal.locator === 'string'
+        || edits.length > 0;
+      const inferredLocatorDrift = failureCategory === undefined
+        && source.status === 'PROPOSED'
+        && typeof legacyProposal.target === 'string'
+        && typeof legacyProposal.locator === 'string';
+
+      if ((failureCategory === 'LOCATOR_DRIFT' || inferredLocatorDrift) && target && locator) {
+        notes.push('Normalized recognized legacy locator proposal into the PIE replacement-operation schema.');
+        return withEnvelope({
+            protocolVersion: '2',
+            responseType: 'FINAL',
+            status: 'PROPOSAL_READY',
+            classification: { category: 'LOCATOR_DRIFT', confidence },
+            reasoningSummary: summary,
+            evidenceReferences,
+            proposal: {
+              proposalVersion: '1',
+              decision: 'PROPOSE',
+              failureKind: 'LOCATOR_DRIFT',
+              confidence,
+              reasoningSummary: summary,
+              operations: [{ kind: 'replace_locator', target, locator }],
+              requiredVerification: ['isolated target test', 'assertions unchanged'],
+              evidenceReferences,
+            },
+            humanApprovalRequired: true,
+          }, notes);
+      }
+
+      if (hasLegacyLocatorShape) {
+        notes.push('Mapped an incomplete or non-locator legacy final proposal to BLOCKED; no mutation operation was synthesized.');
+        return withEnvelope({
+            protocolVersion: '2',
+            responseType: 'FINAL',
+            status: 'BLOCKED',
+            classification: normalizedClassification,
+            reasoningSummary: 'The legacy proposal did not contain a safe LOCATOR_DRIFT replacement operation; no mutation was synthesized.',
+            evidenceReferences,
+            humanApprovalRequired: true,
+          }, notes);
+      }
+    }
+
+    return withEnvelope(source, notes);
+  }
+  if (source.responseType === 'STEP') {
+    const allowedStepKeys = new Set([
+      'protocolVersion', 'responseType', 'status', 'decision', 'confidence',
+      'reasoningSummary', 'evidenceReferences', 'action', 'requiredObservation',
+    ]);
+    if (Object.keys(source).some((key) => !allowedStepKeys.has(key))) return withEnvelope(source);
+  }
+  if (source.responseType !== 'STEP' || source.status !== 'CONTINUE' || !source.action
+    || (typeof source.action !== 'object' && typeof source.action !== 'string')) {
+    return withEnvelope(source);
+  }
+
+  const rawAction = typeof source.action === 'string'
+    ? { kind: source.action }
+    : source.action as Record<string, unknown>;
+  const kind = rawAction.kind;
+  const allowedActionFields = ['kind', 'selector', 'target', 'locator', 'path', 'query', 'testFile', 'configPath', 'sourceFile', 'className', 'memberName', 'reason'];
+  const action: Record<string, unknown> = {};
+  for (const field of allowedActionFields) {
+    if (typeof rawAction[field] === 'string' && rawAction[field].length > 0) action[field] = rawAction[field];
+  }
+  const notes: string[] = [];
+  if (typeof source.action === 'string') notes.push('Normalized a recognized string action into the PIE action object schema.');
+  const legacyProposal = rawAction.proposal;
+  if (legacyProposal && typeof legacyProposal === 'object') {
+    const legacy = legacyProposal as Record<string, unknown>;
+    if (typeof legacy.oldLocator === 'string' && action.target === undefined) action.target = legacy.oldLocator;
+    if (typeof legacy.oldText === 'string' && action.target === undefined) action.target = legacy.oldText;
+    if (typeof legacy.newLocator === 'string' && action.locator === undefined) action.locator = legacy.newLocator;
+    if (typeof legacy.newText === 'string' && action.locator === undefined) action.locator = legacy.newText;
+    const edits = Array.isArray(legacy.edits) ? legacy.edits : Array.isArray(legacy.changes) ? legacy.changes : [];
+    const firstEdit = edits[0] && typeof edits[0] === 'object' && !Array.isArray(edits[0]) ? edits[0] as Record<string, unknown> : {};
+    if (typeof firstEdit.oldLocator === 'string' && action.target === undefined) action.target = firstEdit.oldLocator;
+    if (typeof firstEdit.oldText === 'string' && action.target === undefined) action.target = firstEdit.oldText;
+    if (typeof firstEdit.newLocator === 'string' && action.locator === undefined) action.locator = firstEdit.newLocator;
+    if (typeof firstEdit.newText === 'string' && action.locator === undefined) action.locator = firstEdit.newText;
+    notes.push('Dropped unsupported nested proposal metadata; retained only allowlisted locator fields.');
+  }
+
+  const decisionByAction: Record<string, string> = {
+    inspect_evidence: 'INSPECT_EVIDENCE',
+    inspect_browser_state: 'INSPECT_BROWSER_STATE',
+    inspect_repository: 'INSPECT_REPOSITORY',
+    read_source_file: 'READ_SOURCE_FILE',
+    search_repository: 'SEARCH_REPOSITORY',
+    discover_source_mapping: 'DISCOVER_SOURCE_MAPPING',
+    rank_locator_candidates: 'RANK_LOCATOR_CANDIDATES',
+    build_repair_proposal: 'BUILD_REPAIR_PROPOSAL',
+    run_target_test: 'RUN_TARGET_TEST',
+    verify_repair: 'VERIFY_REPAIR',
+    abstain: 'ABSTAIN',
+  };
+  const normalized: Record<string, unknown> = {
+    protocolVersion: source.protocolVersion === '2' ? '2' : '2',
+    responseType: 'STEP',
+    status: 'CONTINUE',
+    decision: typeof source.decision === 'string' ? source.decision : decisionByAction[String(kind)] ?? kind,
+    confidence: typeof source.confidence === 'number' ? source.confidence : 0,
+    reasoningSummary: typeof source.reasoningSummary === 'string' ? source.reasoningSummary : 'Model requested an allowlisted PIE observation.',
+    evidenceReferences: Array.isArray(source.evidenceReferences) ? source.evidenceReferences.filter((value): value is string => typeof value === 'string') : [],
+    action,
+    requiredObservation: typeof source.requiredObservation === 'string' ? source.requiredObservation : 'Return the PIE action observation.',
+  };
+  if (source.decision === undefined) notes.push('Derived decision from the allowlisted action kind.');
+  if (source.confidence === undefined) notes.push('Applied conservative confidence default 0.');
+  if (source.reasoningSummary === undefined) notes.push('Applied a neutral reasoning summary because none was returned.');
+  if (source.evidenceReferences === undefined) notes.push('Applied an empty evidence-reference list because none was returned.');
+  if (source.requiredObservation === undefined) notes.push('Applied a default observation requirement because none was returned.');
+  return withEnvelope(normalized, notes);
+}
+
+/**
+ * Some OpenAI-compatible endpoints and models place correlation metadata next
+ * to the PIE response object. These fields are transport metadata, not model
+ * instructions. Remove only this explicit allowlist before strict validation;
+ * every other unknown field remains an error.
+ */
+function normalizeAgentEnvelope(input: Record<string, unknown>): {
+  candidate: Record<string, unknown>;
+  notes: string[];
+  metadata?: AgentProtocolMetadata | undefined;
+} {
+  const metadataKeys = [
+    'callId', 'requestId', 'responseId', 'messageId', 'model', 'provider',
+    'finishReason', 'finish_reason', 'usage', 'id',
+  ] as const;
+  const candidate = { ...input };
+  const metadata: AgentProtocolMetadata = {};
+  const notes: string[] = [];
+  for (const key of metadataKeys) {
+    if (!(key in candidate)) continue;
+    const value = candidate[key];
+    delete candidate[key];
+    if (key === 'finish_reason') {
+      if (typeof value === 'string') metadata.finishReason = value;
+    } else if (key === 'usage') {
+      metadata.usage = value;
+    } else if (typeof value === 'string') {
+      switch (key) {
+        case 'callId': metadata.callId = value; break;
+        case 'requestId': metadata.requestId = value; break;
+        case 'responseId': metadata.responseId = value; break;
+        case 'messageId': metadata.messageId = value; break;
+        case 'model': metadata.model = value; break;
+        case 'provider': metadata.provider = value; break;
+        case 'finishReason': metadata.finishReason = value; break;
+        case 'id': metadata.responseId = value; break;
+      }
+    }
+    notes.push(`Normalized recognized response envelope metadata '${key}'.`);
+  }
+  return {
+    candidate,
+    notes,
+    ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+  };
+}
+
+export function parseLlmRepairProposal(input: unknown): ProposalParseResult {
+  const parsedInput = parseJsonInput(input);
+  if (parsedInput.errors.length > 0) return { isValid: false, errors: parsedInput.errors.map((error) => error.replace(/^Response/, 'Proposal')) };
+  const candidate = parsedInput.candidate;
+
+  const parsed = LlmRepairProposalSchema.safeParse(candidate);
+  if (!parsed.success) {
+    return { isValid: false, errors: parsed.error.issues.map((issue) => issue.message) };
+  }
+
+  const operationErrors = parsed.data.operations.flatMap((operation) => {
+    const result = validateRepairOperation(operation);
+    return result.isValid ? [] : [result.reason ?? 'Invalid repair operation'];
+  });
+  if (operationErrors.length > 0) return { isValid: false, errors: operationErrors };
+
+  if (parsed.data.decision === 'ABSTAIN' && parsed.data.operations.some((operation) => operation.kind !== 'abstain')) {
+    return { isValid: false, errors: ['ABSTAIN proposals cannot contain source mutation operations'] };
+  }
+
+  return { isValid: true, proposal: parsed.data, errors: [] };
+}
+
+export function proposalOperations(proposal: LlmRepairProposal): RepairOperation[] {
+  return proposal.operations;
+}
+
+export function parseAgentResponse(input: unknown): AgentResponseParseResult {
+  const parsedInput = parseJsonInput(input);
+  if (parsedInput.errors.length > 0) return { isValid: false, errors: parsedInput.errors };
+  const normalized = normalizeAgentCandidate(parsedInput.candidate);
+  const parsed = AgentResponseSchema.safeParse(normalized.candidate);
+  if (!parsed.success) return {
+    isValid: false,
+    errors: parsed.error.issues.map((issue) => issue.message),
+    normalizationNotes: normalized.notes,
+    protocolMetadata: normalized.metadata,
+  };
+  if (parsed.data.responseType === 'FINAL' && parsed.data.proposal) {
+    const proposal = parseLlmRepairProposal(parsed.data.proposal);
+    if (!proposal.isValid || !proposal.proposal) return { isValid: false, errors: proposal.errors, normalizationNotes: normalized.notes, protocolMetadata: normalized.metadata };
+    return { isValid: true, response: { ...parsed.data, proposal: proposal.proposal }, errors: [], normalizationNotes: normalized.notes, protocolMetadata: normalized.metadata };
+  }
+  return { isValid: true, response: parsed.data, errors: [], normalizationNotes: normalized.notes, protocolMetadata: normalized.metadata };
+}
+