Initial commit (unpacked platform)

2026-08-05 19:21:11 +07:00
commit ac5340195a
314 changed files with 57584 additions and 0 deletions
@@ -0,0 +1,495 @@
+import { z } from "zod";
+import { AI_CONTRACT_VERSION, UNITS } from "@app/shared-types";
+
+/**
+ * AAMOS-uppgiftstyper. Superset av köns jobbtyper (spec §54): vissa jobb i
+ * plattformen-workern är rena AAMOS-anrop, andra är deterministiska och anropar
+ * aldrig AI. Kontraktet här är versionerat – AAMOS kan byta modeller fritt
+ * bakom det (spec §31: "Food API ska få stabila kontrakt oavsett modell").
+ */
+export const AAMOS_TASK_TYPES = [
+  "ANALYZE_FRIDGE_IMAGE",
+  "ANALYZE_PANTRY_IMAGE",
+  "ANALYZE_MEAL_IMAGE",
+  "READ_RECEIPT",
+  "READ_NUTRITION_LABEL",
+  "READ_EXPIRY_DATE",
+  "NORMALIZE_PRODUCTS",
+  "DEDUPLICATE_INVENTORY",
+  "STRUCTURE_RECIPE_TEXT",
+  "GENERATE_RECIPE_OPTIONS",
+  "RANK_RECIPES",
+  "PARSE_CRAVING",
+  "UPDATE_USER_MEMORY",
+  "GENERATE_WEEK_PLAN",
+  "MODERATE_RECIPE",
+  "TRANSLATE_RECIPE",
+] as const;
+export type AamosTaskType = (typeof AAMOS_TASK_TYPES)[number];
+
+const unitSchema = z.enum(UNITS);
+const confidence = z.number().min(0).max(1);
+const isoDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+
+/**
+ * Ett detekterat objekt från bildanalys (spec §10). AI får alltid säga
+ * "osäker/okänd": canonicalIngredientId=null + lågt confidence.
+ */
+export const detectedItemSchema = z.object({
+  detectedName: z.string(),
+  canonicalIngredientId: z.string().nullable(),
+  brand: z.string().nullable().default(null),
+  estimatedQuantity: z.number().nullable(),
+  unit: unitSchema.nullable(),
+  bestBeforeDate: isoDate.nullable().default(null),
+  confidence,
+  requiresConfirmation: z.boolean(),
+  boundingBox: z
+    .object({ x: z.number(), y: z.number(), w: z.number(), h: z.number() })
+    .nullable()
+    .default(null),
+});
+export type DetectedItem = z.infer<typeof detectedItemSchema>;
+
+// ---------------------------------------------------------------------------
+// Input/Output per uppgiftstyp
+// ---------------------------------------------------------------------------
+
+export const analyzeStorageImageInput = z.object({
+  imageUrls: z.array(z.url()).min(1).max(6),
+  locationType: z.string(),
+  marketLocale: z.string().default("sv-SE"),
+  knownItems: z.array(z.string()).default([]),
+});
+export const analyzeStorageImageOutput = z.object({
+  items: z.array(detectedItemSchema),
+  imageQualityIssues: z.array(z.enum(["dark", "blurry", "occlusion", "too_far"])).default([]),
+});
+
+export const analyzeMealImageInput = z.object({
+  imageUrls: z.array(z.url()).min(1).max(3),
+  recipeContext: z
+    .object({
+      recipeId: z.string(),
+      titleSv: z.string(),
+      nutritionPerPortion: z.record(z.string(), z.number()),
+      portions: z.number(),
+    })
+    .nullable()
+    .default(null),
+  marketLocale: z.string().default("sv-SE"),
+});
+/**
+ * Tallriksfoto (spec §22): intervall + mest sannolikt, aldrig exakt påstående.
+ * Kalorierna här är UPPSKATTNINGAR som användaren måste kunna korrigera.
+ */
+export const analyzeMealImageOutput = z.object({
+  matchesRecipeContext: z.boolean().nullable(),
+  portionFractionEstimate: z.number().min(0).max(5).nullable(),
+  kcalRange: z.object({ min: z.number(), max: z.number(), mostLikely: z.number() }).nullable(),
+  components: z
+    .array(
+      z.object({
+        name: z.string(),
+        canonicalIngredientId: z.string().nullable(),
+        estimatedGrams: z.number().nullable(),
+        confidence,
+      }),
+    )
+    .default([]),
+  confidence,
+});
+
+export const readReceiptInput = z.object({
+  imageUrls: z.array(z.url()).min(1).max(4),
+  marketLocale: z.string().default("sv-SE"),
+});
+export const readReceiptOutput = z.object({
+  storeName: z.string().nullable(),
+  purchaseDate: isoDate.nullable(),
+  lines: z.array(
+    z.object({
+      rawText: z.string(),
+      normalizedName: z.string().nullable(),
+      canonicalIngredientId: z.string().nullable(),
+      quantity: z.number().nullable(),
+      unit: unitSchema.nullable(),
+      unitPriceMinor: z.number().int().nullable(),
+      totalPriceMinor: z.number().int().nullable(),
+      isDiscount: z.boolean().default(false),
+      confidence,
+    }),
+  ),
+  totalMinor: z.number().int().nullable(),
+  discountTotalMinor: z.number().int().nullable(),
+  confidence,
+});
+
+export const readNutritionLabelInput = z.object({
+  imageUrls: z.array(z.url()).min(1).max(3),
+  marketLocale: z.string().default("sv-SE"),
+});
+/** OCR av näringsdeklaration – värden kommer från ETIKETTEN, aldrig från modellens gissning. */
+export const readNutritionLabelOutput = z.object({
+  basis: z.enum(["per_100_g", "per_100_ml", "per_portion"]).nullable(),
+  values: z
+    .object({
+      kcal: z.number().nullable(),
+      proteinG: z.number().nullable(),
+      carbsG: z.number().nullable(),
+      fatG: z.number().nullable(),
+      saturatedFatG: z.number().nullable(),
+      fiberG: z.number().nullable(),
+      sugarG: z.number().nullable(),
+      saltG: z.number().nullable(),
+    })
+    .nullable(),
+  ingredientsText: z.string().nullable(),
+  allergensDeclared: z.array(z.string()).default([]),
+  gtin: z.string().nullable().default(null),
+  productName: z.string().nullable().default(null),
+  brand: z.string().nullable().default(null),
+  confidence,
+});
+
+export const readExpiryDateInput = z.object({
+  imageUrls: z.array(z.url()).min(1).max(2),
+});
+export const readExpiryDateOutput = z.object({
+  date: isoDate.nullable(),
+  dateKind: z.enum(["best_before", "use_by"]).nullable(),
+  confidence,
+});
+
+export const normalizeProductsInput = z.object({
+  rawNames: z.array(z.string()).min(1).max(100),
+  marketLocale: z.string().default("sv-SE"),
+});
+export const normalizeProductsOutput = z.object({
+  matches: z.array(
+    z.object({
+      raw: z.string(),
+      canonicalIngredientId: z.string().nullable(),
+      normalizedName: z.string().nullable(),
+      confidence,
+    }),
+  ),
+});
+
+export const deduplicateInventoryInput = z.object({
+  items: z.array(
+    z.object({
+      id: z.string(),
+      displayName: z.string(),
+      canonicalIngredientId: z.string().nullable(),
+      quantity: z.number(),
+      unit: unitSchema,
+      source: z.string(),
+      createdAt: z.string(),
+    }),
+  ),
+});
+export const deduplicateInventoryOutput = z.object({
+  duplicateGroups: z.array(
+    z.object({
+      itemIds: z.array(z.string()).min(2),
+      confidence,
+      suggestedAction: z.enum(["merge", "review"]),
+      reasonSv: z.string(),
+    }),
+  ),
+});
+
+/** Fritextrecept → struktur (spec §35). Näring räknas ALDRIG här – det gör nutrition-engine. */
+export const structureRecipeTextInput = z.object({
+  text: z.string().min(20).max(8000),
+  marketLocale: z.string().default("sv-SE"),
+});
+export const structureRecipeTextOutput = z.object({
+  titleSv: z.string().nullable(),
+  descriptionSv: z.string().nullable(),
+  ingredients: z.array(
+    z.object({
+      rawText: z.string(),
+      canonicalIngredientId: z.string().nullable(),
+      displayNameSv: z.string(),
+      quantity: z.number().nullable(),
+      unit: unitSchema.nullable(),
+      optional: z.boolean().default(false),
+      confidence,
+    }),
+  ),
+  steps: z.array(
+    z.object({
+      instructionSv: z.string(),
+      timerSeconds: z.number().nullable().default(null),
+      temperatureC: z.number().nullable().default(null),
+    }),
+  ),
+  prepTimeMinutes: z.number().nullable(),
+  cookTimeMinutes: z.number().nullable(),
+  portions: z.number().nullable(),
+  suggestedCuisine: z.string().nullable(),
+  suggestedMealTypes: z.array(z.string()).default([]),
+  confidence,
+});
+
+export const generateRecipeOptionsInput = z.object({
+  cravingText: z.string().nullable(),
+  pantrySummary: z.array(
+    z.object({ canonicalIngredientId: z.string(), quantity: z.number(), unit: unitSchema }),
+  ),
+  constraints: z.object({
+    allergens: z.array(z.string()),
+    dietPattern: z.string().nullable(),
+    maxMinutes: z.number().nullable(),
+    portions: z.number(),
+    spiceLevelMax: z.number().nullable(),
+  }),
+  marketLocale: z.string().default("sv-SE"),
+});
+/**
+ * AI-assisterade originalförslag (spec §15) – går ALLTID via redaktionell
+ * granskning innan de blir permanenta recept. Allergensäkerhet verifieras
+ * deterministiskt av recipe-engine innan visning.
+ */
+export const generateRecipeOptionsOutput = z.object({
+  suggestions: z.array(
+    z.object({
+      titleSv: z.string(),
+      descriptionSv: z.string(),
+      ingredients: z.array(
+        z.object({
+          canonicalIngredientId: z.string().nullable(),
+          displayNameSv: z.string(),
+          quantity: z.number(),
+          unit: unitSchema,
+        }),
+      ),
+      steps: z.array(z.string()),
+      estimatedTimeMinutes: z.number(),
+      confidence,
+    }),
+  ),
+});
+
+export const rankRecipesInput = z.object({
+  candidateIds: z.array(z.string()).max(50),
+  deterministicScores: z.record(z.string(), z.number()),
+  contextSummary: z.string(),
+});
+export const rankRecipesOutput = z.object({
+  rankedIds: z.array(z.string()),
+  rationaleSv: z.string().nullable(),
+});
+
+export const parseCravingInput = z.object({
+  text: z.string().max(500),
+  marketLocale: z.string().default("sv-SE"),
+});
+export const parseCravingOutput = z.object({
+  tags: z.array(z.string()),
+  cuisine: z.string().nullable(),
+  maxKcal: z.number().nullable(),
+  confidence,
+});
+
+export const updateUserMemoryInput = z.object({
+  scope: z.enum(["user", "household"]),
+  scopeId: z.string(),
+  events: z.array(
+    z.object({
+      type: z.string(),
+      occurredAt: z.string(),
+      payload: z.unknown(),
+    }),
+  ),
+  existingMemoryKeys: z.array(z.string()).default([]),
+});
+export const updateUserMemoryOutput = z.object({
+  memoryUpdates: z.array(
+    z.object({
+      key: z.string(),
+      kind: z.enum(["structured_fact", "event", "semantic", "profile_summary", "recipe_memory"]),
+      summarySv: z.string(),
+      value: z.unknown(),
+      origin: z.enum(["observed", "ai_inferred"]),
+      confidence,
+      expiresAt: z.string().nullable().default(null),
+    }),
+  ),
+});
+
+export const generateWeekPlanInput = z.object({
+  days: z.array(z.object({ date: isoDate, mealTypes: z.array(z.string()) })),
+  pantrySummary: z.array(
+    z.object({
+      canonicalIngredientId: z.string(),
+      quantity: z.number(),
+      unit: unitSchema,
+      daysToExpiry: z.number().nullable(),
+    }),
+  ),
+  candidateRecipes: z.array(
+    z.object({ id: z.string(), titleSv: z.string(), tags: z.array(z.string()) }),
+  ),
+  constraints: z.object({
+    budgetMinorTotal: z.number().int().nullable(),
+    portionsPerMeal: z.number(),
+    varietyLevel: z.enum(["low", "medium", "high"]),
+    noteSv: z.string().nullable(),
+  }),
+});
+export const generateWeekPlanOutput = z.object({
+  entries: z.array(
+    z.object({
+      date: isoDate,
+      mealType: z.string(),
+      recipeId: z.string().nullable(),
+      useMealBox: z.boolean().default(false),
+      motivationSv: z.string().nullable(),
+    }),
+  ),
+  confidence,
+});
+
+export const moderateRecipeInput = z.object({
+  titleSv: z.string(),
+  descriptionSv: z.string(),
+  ingredients: z.array(z.string()),
+  steps: z.array(z.string()),
+});
+export const moderateRecipeOutput = z.object({
+  flags: z.array(
+    z.object({
+      code: z.enum([
+        "food_safety",
+        "unrealistic_quantities",
+        "inappropriate_content",
+        "spam",
+        "copyright_suspect",
+        "other",
+      ]),
+      severity: z.enum(["info", "warning", "reject"]),
+      messageSv: z.string(),
+    }),
+  ),
+  recommendation: z.enum(["approve", "review", "reject"]),
+  confidence,
+});
+
+// ---------------------------------------------------------------------------
+// TRANSLATE_RECIPE (i18n-spec §13–14): AI översätter TEXT, aldrig struktur.
+// Mängder, ingredient-IDs, tider och allergener bor utanför översättningen och
+// kan därför inte ändras av modellen. Deterministisk verifiering sker i worker.
+// ---------------------------------------------------------------------------
+
+export const translateRecipeInput = z.object({
+  sourceLanguageTag: z.string().default("sv"),
+  targetLanguageTag: z.string(),
+  title: z.string(),
+  description: z.string().nullable(),
+  storageGuidance: z.string().nullable(),
+  steps: z.array(
+    z.object({
+      stepNumber: z.number().int().min(1),
+      instruction: z.string(),
+      tip: z.string().nullable(),
+    }),
+  ),
+});
+export const translateRecipeOutput = z.object({
+  title: z.string().min(1),
+  description: z.string().nullable(),
+  storageGuidance: z.string().nullable(),
+  steps: z.array(
+    z.object({
+      stepNumber: z.number().int().min(1),
+      instruction: z.string().min(1),
+      tip: z.string().nullable(),
+    }),
+  ),
+  confidence,
+});
+
+// ---------------------------------------------------------------------------
+// Kontraktsregister
+// ---------------------------------------------------------------------------
+
+export const TASK_CONTRACTS = {
+  ANALYZE_FRIDGE_IMAGE: { input: analyzeStorageImageInput, output: analyzeStorageImageOutput },
+  ANALYZE_PANTRY_IMAGE: { input: analyzeStorageImageInput, output: analyzeStorageImageOutput },
+  ANALYZE_MEAL_IMAGE: { input: analyzeMealImageInput, output: analyzeMealImageOutput },
+  READ_RECEIPT: { input: readReceiptInput, output: readReceiptOutput },
+  READ_NUTRITION_LABEL: { input: readNutritionLabelInput, output: readNutritionLabelOutput },
+  READ_EXPIRY_DATE: { input: readExpiryDateInput, output: readExpiryDateOutput },
+  NORMALIZE_PRODUCTS: { input: normalizeProductsInput, output: normalizeProductsOutput },
+  DEDUPLICATE_INVENTORY: { input: deduplicateInventoryInput, output: deduplicateInventoryOutput },
+  STRUCTURE_RECIPE_TEXT: { input: structureRecipeTextInput, output: structureRecipeTextOutput },
+  GENERATE_RECIPE_OPTIONS: {
+    input: generateRecipeOptionsInput,
+    output: generateRecipeOptionsOutput,
+  },
+  RANK_RECIPES: { input: rankRecipesInput, output: rankRecipesOutput },
+  PARSE_CRAVING: { input: parseCravingInput, output: parseCravingOutput },
+  UPDATE_USER_MEMORY: { input: updateUserMemoryInput, output: updateUserMemoryOutput },
+  GENERATE_WEEK_PLAN: { input: generateWeekPlanInput, output: generateWeekPlanOutput },
+  MODERATE_RECIPE: { input: moderateRecipeInput, output: moderateRecipeOutput },
+  TRANSLATE_RECIPE: { input: translateRecipeInput, output: translateRecipeOutput },
+} as const satisfies Record<AamosTaskType, { input: z.ZodType; output: z.ZodType }>;
+
+export type TaskInput<T extends AamosTaskType> = z.infer<(typeof TASK_CONTRACTS)[T]["input"]>;
+export type TaskOutput<T extends AamosTaskType> = z.infer<(typeof TASK_CONTRACTS)[T]["output"]>;
+
+/** Kuvert för anrop mot AAMOS. */
+export const aamosRequestEnvelopeSchema = z.object({
+  taskId: z.string(),
+  taskType: z.enum(AAMOS_TASK_TYPES),
+  contractVersion: z.string().default(AI_CONTRACT_VERSION),
+  input: z.unknown(),
+  metadata: z.object({
+    correlationId: z.string(),
+    /** Lokaliseringskontext (i18n-spec §22): AAMOS svarar på rätt språk och
+     *  respekterar region/måttsystem – canonical data förblir språkneutral. */
+    localeContext: z
+      .object({
+        languageTag: z.string(),
+        regionCode: z.string(),
+        timeZone: z.string(),
+        measurementSystem: z.enum(["METRIC", "US_CUSTOMARY", "MIXED"]),
+        temperatureUnit: z.enum(["CELSIUS", "FAHRENHEIT"]),
+        currencyCode: z.string(),
+      })
+      .default({
+        languageTag: "sv-SE",
+        regionCode: "SE",
+        timeZone: "Europe/Stockholm",
+        measurementSystem: "METRIC",
+        temperatureUnit: "CELSIUS",
+        currencyCode: "SEK",
+      }),
+    /** Pseudonymiserat – aldrig e-post eller namn till AAMOS (spec §56). */
+    subjectRef: z.string().nullable(),
+    priority: z.enum(["low", "normal", "high"]).default("normal"),
+    consentFlags: z.object({
+      personalization: z.boolean(),
+      anonymizedImprovement: z.boolean(),
+      imageTraining: z.boolean(),
+    }),
+  }),
+});
+export type AamosRequestEnvelope = z.infer<typeof aamosRequestEnvelopeSchema>;
+
+export const aamosResponseEnvelopeSchema = z.object({
+  taskId: z.string(),
+  taskType: z.enum(AAMOS_TASK_TYPES),
+  contractVersion: z.string(),
+  status: z.enum(["ok", "uncertain", "failed"]),
+  output: z.unknown().nullable(),
+  error: z.string().nullable().default(null),
+  modelVersion: z.string().nullable().default(null),
+  promptVersion: z.string().nullable().default(null),
+  latencyMs: z.number().nullable().default(null),
+  costUsd: z.number().nullable().default(null),
+});
+export type AamosResponseEnvelope = z.infer<typeof aamosResponseEnvelopeSchema>;