Jesse_Chen
337 lines
13 KiB
TypeScript
337 lines
13 KiB
TypeScript
import { z } from "zod";
|
|
|
|
export const rectificationV4Protocol = "rectification-evidence-v4" as const;
|
|
export const rectificationAgentV5Protocol = "rectification-evidence-v5" as const;
|
|
export const rectificationDeploymentModeSchema = z.enum(["v4_legacy", "v5_shadow", "v5_agent"]);
|
|
export type RectificationDeploymentMode = z.infer<typeof rectificationDeploymentModeSchema>;
|
|
export const rectificationV4AlgorithmVersion = "rectification-v5-matrix-scoring-1" as const;
|
|
|
|
export const rectificationV4CaseStatusSchema = z.enum([
|
|
"awaiting_answer",
|
|
"processing",
|
|
"range_ready",
|
|
"paused",
|
|
"abandoned",
|
|
]);
|
|
export type RectificationV4CaseStatus = z.infer<typeof rectificationV4CaseStatusSchema>;
|
|
|
|
export const rectificationV4PhaseSchema = z.enum([
|
|
"collecting_evidence",
|
|
"extracting_evidence",
|
|
"scoring_candidates",
|
|
"checking_robustness",
|
|
"planning_question",
|
|
"reasoning",
|
|
"rendering",
|
|
"complete",
|
|
]);
|
|
export type RectificationV4Phase = z.infer<typeof rectificationV4PhaseSchema>;
|
|
|
|
export const evidenceDomainSchema = z.enum([
|
|
"education",
|
|
"relocation",
|
|
"relationship",
|
|
"career",
|
|
"finance",
|
|
"health_pressure",
|
|
"family",
|
|
"other",
|
|
]);
|
|
export type EvidenceDomain = z.infer<typeof evidenceDomainSchema>;
|
|
|
|
export const eventKindSchema = z.enum([
|
|
"education_milestone",
|
|
"relocation",
|
|
"relationship_start",
|
|
"relationship_end",
|
|
"career_change",
|
|
"finance_change",
|
|
"self_health_event",
|
|
"family_health_event",
|
|
"family_bereavement",
|
|
"relationship_change",
|
|
"family_event",
|
|
"other",
|
|
]);
|
|
export type EventKind = z.infer<typeof eventKindSchema>;
|
|
|
|
export const datePrecisionSchema = z.enum(["day", "month", "quarter", "year", "range"]);
|
|
export type DatePrecision = z.infer<typeof datePrecisionSchema>;
|
|
|
|
export const calendarDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
|
|
export const clockTimeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/);
|
|
|
|
export const eventDateRangeSchema = z.object({
|
|
start: calendarDateSchema,
|
|
end: calendarDateSchema,
|
|
precision: datePrecisionSchema,
|
|
label: z.string().trim().min(1).max(80),
|
|
}).strict().superRefine((value, context) => {
|
|
if (value.start > value.end) {
|
|
context.addIssue({ code: "custom", message: "event date range start must not exceed end" });
|
|
}
|
|
});
|
|
export type EventDateRange = z.infer<typeof eventDateRangeSchema>;
|
|
|
|
export const eventSubjectSchema = z.enum(["self", "family", "partner", "other"]);
|
|
export type EventSubject = z.infer<typeof eventSubjectSchema>;
|
|
|
|
export const relatedPersonSchema = z.enum(["father", "mother", "grandparent", "sibling", "partner"]);
|
|
export type RelatedPerson = z.infer<typeof relatedPersonSchema>;
|
|
|
|
export const scoreabilitySchema = z.enum(["scoreable", "context_only", "pending_review", "unsupported"]);
|
|
export type Scoreability = z.infer<typeof scoreabilitySchema>;
|
|
|
|
export const lifeEventRevisionSchema = z.object({
|
|
id: z.string().uuid(),
|
|
eventId: z.string().uuid(),
|
|
revision: z.number().int().positive(),
|
|
domain: evidenceDomainSchema,
|
|
eventKind: eventKindSchema,
|
|
subject: eventSubjectSchema,
|
|
relatedPerson: relatedPersonSchema.nullable(),
|
|
summary: z.string().trim().min(1).max(1_000),
|
|
rawText: z.string().trim().min(1).max(4_000),
|
|
dateRange: eventDateRangeSchema,
|
|
scoreability: scoreabilitySchema,
|
|
supersedesRevisionId: z.string().uuid().nullable(),
|
|
createdAt: z.string().datetime({ offset: true }),
|
|
}).strict();
|
|
export type LifeEventRevision = z.infer<typeof lifeEventRevisionSchema>;
|
|
|
|
export const pendingEvidenceSchema = z.object({
|
|
id: z.string().uuid(),
|
|
caseId: z.string().uuid(),
|
|
turnId: z.string().uuid(),
|
|
rawText: z.string().trim().min(1).max(4_000),
|
|
reasonCode: z.enum(["date_unresolved", "event_unparsed"]),
|
|
targetEventId: z.string().uuid().nullable(),
|
|
resolvedEventId: z.string().uuid().nullable(),
|
|
createdAt: z.string().datetime({ offset: true }),
|
|
resolvedAt: z.string().datetime({ offset: true }).nullable(),
|
|
}).strict();
|
|
export type PendingEvidence = z.infer<typeof pendingEvidenceSchema>;
|
|
|
|
export const calculationSpecSchema = z.object({
|
|
version: z.literal("rectification-calculation-spec-v4"),
|
|
birthDate: calendarDateSchema,
|
|
candidateRange: z.object({ start: clockTimeSchema, end: clockTimeSchema }).strict(),
|
|
latitude: z.number().finite().min(-90).max(90),
|
|
longitude: z.number().finite().min(-180).max(180),
|
|
timezoneOffsetHours: z.number().finite().min(-14).max(14),
|
|
ayanamsa: z.literal("lahiri"),
|
|
nodeMode: z.literal("mean"),
|
|
minuteStep: z.literal(1),
|
|
}).strict();
|
|
export type CalculationSpec = z.infer<typeof calculationSpecSchema>;
|
|
|
|
export const candidateMinuteSchema = z.object({
|
|
time: clockTimeSchema,
|
|
score: z.number().finite(),
|
|
supportingEventIds: z.array(z.string().uuid()),
|
|
conflictingEventIds: z.array(z.string().uuid()),
|
|
}).strict();
|
|
export type CandidateMinute = z.infer<typeof candidateMinuteSchema>;
|
|
|
|
export const candidateClusterSchema = z.object({
|
|
rank: z.number().int().positive(),
|
|
startTime: clockTimeSchema,
|
|
endTime: clockTimeSchema,
|
|
representativeTime: clockTimeSchema,
|
|
widthMinutes: z.number().int().positive(),
|
|
peakScore: z.number().finite(),
|
|
scoreMass: z.number().finite().nonnegative(),
|
|
}).strict();
|
|
export type CandidateCluster = z.infer<typeof candidateClusterSchema>;
|
|
|
|
export const robustnessSchema = z.object({
|
|
neighborSupportMinutes: z.number().int().nonnegative(),
|
|
leaveOneOutRetentionRate: z.number().finite().min(0).max(1),
|
|
dateSensitivityRetentionRate: z.number().finite().min(0).max(1),
|
|
calculationSpecHashMatched: z.boolean(),
|
|
}).strict();
|
|
export type Robustness = z.infer<typeof robustnessSchema>;
|
|
|
|
export const candidateSnapshotSchema = z.object({
|
|
id: z.string().uuid(),
|
|
caseId: z.string().uuid(),
|
|
caseVersion: z.number().int().nonnegative(),
|
|
evidenceSetHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
calculationSpecHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
algorithmVersion: z.literal(rectificationV4AlgorithmVersion),
|
|
candidates: z.array(candidateMinuteSchema).min(1).max(1_440),
|
|
clusters: z.array(candidateClusterSchema).max(20),
|
|
robustness: robustnessSchema,
|
|
canConfirmExactMinute: z.literal(false),
|
|
canAcceptRange: z.boolean(),
|
|
gateReasons: z.array(z.string().trim().min(1).max(120)).max(20),
|
|
createdAt: z.string().datetime({ offset: true }),
|
|
}).strict();
|
|
export type CandidateSnapshot = z.infer<typeof candidateSnapshotSchema>;
|
|
|
|
export const rectificationV4QuestionSchema = z.object({
|
|
id: z.string().uuid(),
|
|
domain: evidenceDomainSchema,
|
|
targetEventId: z.string().uuid().nullable(),
|
|
prompt: z.string().trim().min(1).max(1_000),
|
|
recallCost: z.enum(["low", "medium", "high"]),
|
|
reason: z.string().trim().min(1).max(240),
|
|
}).strict();
|
|
export type RectificationV4Question = z.infer<typeof rectificationV4QuestionSchema>;
|
|
|
|
export const rectificationV4TurnSchema = z.object({
|
|
id: z.string().uuid(),
|
|
caseId: z.string().uuid(),
|
|
caseVersion: z.number().int().positive(),
|
|
questionId: z.string().uuid().nullable(),
|
|
questionDomain: evidenceDomainSchema.nullable(),
|
|
questionTargetEventId: z.string().uuid().nullable(),
|
|
question: z.string().trim().min(1).max(1_000),
|
|
answer: z.string().max(4_000),
|
|
modelId: z.string().trim().min(1).max(120).nullable(),
|
|
actionId: z.string().uuid(),
|
|
createdAt: z.string().datetime({ offset: true }),
|
|
}).strict();
|
|
export type RectificationV4Turn = z.infer<typeof rectificationV4TurnSchema>;
|
|
|
|
export const rectificationV4CaseSchema = z.object({
|
|
id: z.string().uuid(),
|
|
userId: z.string().uuid(),
|
|
protocol: z.union([z.literal(rectificationV4Protocol), z.literal(rectificationAgentV5Protocol)]),
|
|
version: z.number().int().nonnegative(),
|
|
status: rectificationV4CaseStatusSchema,
|
|
phase: rectificationV4PhaseSchema,
|
|
calculationSpec: calculationSpecSchema,
|
|
calculationSpecHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
evidenceSetHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
currentQuestion: rectificationV4QuestionSchema.nullable(),
|
|
latestSnapshot: candidateSnapshotSchema.nullable(),
|
|
orchestrationModelId: z.string().trim().min(1).max(120).nullable(),
|
|
narrationModelId: z.string().trim().min(1).max(120).nullable(),
|
|
skillVersion: z.string().trim().min(1).max(120),
|
|
promptVersion: z.string().trim().min(1).max(120),
|
|
algorithmVersion: z.string().trim().min(1).max(120),
|
|
deploymentMode: rectificationDeploymentModeSchema,
|
|
agentMode: z.enum(["agent", "deterministic_fallback"]),
|
|
featureSnapshotId: z.string().uuid().nullable(),
|
|
latestDiagnosticsId: z.string().uuid().nullable(),
|
|
acceptedRange: z.object({ start: clockTimeSchema, end: clockTimeSchema }).strict().nullable(),
|
|
createdAt: z.string().datetime({ offset: true }),
|
|
updatedAt: z.string().datetime({ offset: true }),
|
|
}).strict();
|
|
export type RectificationV4Case = z.infer<typeof rectificationV4CaseSchema>;
|
|
|
|
export const createCaseRequestSchema = z.object({
|
|
actionId: z.string().uuid(),
|
|
uncertaintyMinutes: z.number().int().min(5).max(720).optional(),
|
|
}).strict();
|
|
|
|
export const answerRequestSchema = z.object({
|
|
actionId: z.string().uuid(),
|
|
expectedCaseVersion: z.number().int().nonnegative(),
|
|
answer: z.string().trim().min(1).max(4_000),
|
|
modelId: z.string().trim().min(1).max(120).nullable().optional(),
|
|
}).strict();
|
|
|
|
export const reviseEventRequestSchema = z.object({
|
|
actionId: z.string().uuid(),
|
|
expectedCaseVersion: z.number().int().nonnegative(),
|
|
domain: evidenceDomainSchema,
|
|
eventKind: eventKindSchema,
|
|
subject: eventSubjectSchema,
|
|
relatedPerson: relatedPersonSchema.nullable(),
|
|
summary: z.string().trim().min(1).max(1_000),
|
|
rawText: z.string().trim().min(1).max(4_000),
|
|
dateRange: eventDateRangeSchema,
|
|
scoreability: scoreabilitySchema.optional(),
|
|
}).strict();
|
|
|
|
export const caseActionRequestSchema = z.object({
|
|
actionId: z.string().uuid(),
|
|
expectedCaseVersion: z.number().int().nonnegative(),
|
|
}).strict();
|
|
|
|
export const acceptRangeRequestSchema = caseActionRequestSchema.extend({
|
|
startTime: clockTimeSchema,
|
|
endTime: clockTimeSchema,
|
|
}).strict();
|
|
|
|
export const rectificationV4JobSchema = z.object({
|
|
id: z.string().uuid(),
|
|
caseId: z.string().uuid(),
|
|
status: z.enum(["pending", "processing", "completed", "failed", "stale"]),
|
|
phase: rectificationV4PhaseSchema,
|
|
expectedCaseVersion: z.number().int().nonnegative(),
|
|
evidenceSetHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
calculationSpecHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
errorCode: z.string().trim().min(1).max(120).nullable(),
|
|
createdAt: z.string().datetime({ offset: true }),
|
|
updatedAt: z.string().datetime({ offset: true }),
|
|
}).strict();
|
|
export type RectificationV4Job = z.infer<typeof rectificationV4JobSchema>;
|
|
|
|
export const rectificationAnalysisStageSchema = z.object({
|
|
phase: z.enum([
|
|
"extracting_evidence",
|
|
"scoring_candidates",
|
|
"checking_robustness",
|
|
"planning_question",
|
|
"reasoning",
|
|
"rendering",
|
|
]),
|
|
label: z.string().trim().min(1).max(120),
|
|
status: z.enum(["completed", "failed"]),
|
|
durationMs: z.number().int().min(0).max(300_000).nullable(),
|
|
}).strict();
|
|
|
|
export const rectificationAnalysisToolCallSchema = z.object({
|
|
category: z.enum(["candidate_engine", "diagnostic", "agent_diagnostic"]),
|
|
label: z.string().trim().min(1).max(120),
|
|
outcome: z.enum(["succeeded", "failed", "rejected"]),
|
|
durationMs: z.number().int().min(0).max(300_000).nullable(),
|
|
}).strict();
|
|
|
|
export const rectificationAnalysisTraceSchema = z.object({
|
|
status: z.enum(["completed", "failed", "legacy"]),
|
|
stages: z.array(rectificationAnalysisStageSchema).max(12),
|
|
toolCalls: z.array(rectificationAnalysisToolCallSchema).max(16),
|
|
techniques: z.array(z.string().trim().min(1).max(120)).max(24),
|
|
reasoningSummary: z.string().trim().min(1).max(500).nullable(),
|
|
reasoningSource: z.enum(["provider_summary", "none"]),
|
|
}).strict();
|
|
export type RectificationAnalysisTrace = z.infer<typeof rectificationAnalysisTraceSchema>;
|
|
|
|
export const rectificationAnalysisItemSchema = z.object({
|
|
sourceTurnId: z.string().uuid(),
|
|
trace: rectificationAnalysisTraceSchema,
|
|
}).strict();
|
|
export type RectificationAnalysisItem = z.infer<typeof rectificationAnalysisItemSchema>;
|
|
|
|
export const rectificationV4ApiResponseSchema = z.object({
|
|
case: rectificationV4CaseSchema,
|
|
job: rectificationV4JobSchema.nullable(),
|
|
events: z.array(lifeEventRevisionSchema),
|
|
turns: z.array(rectificationV4TurnSchema),
|
|
analysis: z.array(rectificationAnalysisItemSchema).optional(),
|
|
}).strict();
|
|
export type RectificationV4ApiResponse = z.infer<typeof rectificationV4ApiResponseSchema>;
|
|
|
|
export const rectificationV4HandoffStatusSchema = z.enum([
|
|
"pending",
|
|
"claimed",
|
|
"in_progress",
|
|
"consumed",
|
|
]);
|
|
|
|
export const rectificationV4HandoffSchema = z.object({
|
|
protocol: z.union([z.literal(rectificationV4Protocol), z.literal(rectificationAgentV5Protocol)]),
|
|
caseId: z.string().uuid(),
|
|
caseVersion: z.number().int().nonnegative(),
|
|
question: z.string().trim().min(1).max(500),
|
|
questionFingerprint: z.string().regex(/^[0-9a-f]{64}$/),
|
|
requestId: z.string().uuid(),
|
|
status: rectificationV4HandoffStatusSchema,
|
|
acceptedRange: z.object({ start: clockTimeSchema, end: clockTimeSchema }).strict().nullable(),
|
|
}).strict();
|
|
export type RectificationV4Handoff = z.infer<typeof rectificationV4HandoffSchema>;
|