@cravery/core 0.0.21 → 0.0.23

package/src/lib/ai/flow.ts

@@ -1,89 +1,89 @@
-import { z } from "genkit";
-import { AI_MODELS } from "../../config/ai";
-import { logAIUsage } from "./cost";
-import { ai } from "./genkit";
-import { uploadImageToStorage } from "../storage";
-import { AIModelConfig } from "../../types";
-
-export const ImagenOutputSchema = z.object({
-  images: z.array(
-    z.object({
-      url: z.string(),
-      path: z.string(),
-    }),
-  ),
-});
-
-export type FlowHandler<T, R> = (input: T, output: R | null) => Promise<R>;
-export type ImageFlowHandler<T> = (
-  input: T,
-  prompt: string,
-) => Promise<{ base64Data: string; storagePath: string }[]>;
-
-export const createGeminiFlow = <T, R>(
-  name: string,
-  inputSchema: z.ZodSchema<T>,
-  outputSchema: z.ZodSchema<R>,
-  handler: FlowHandler<T, R>,
-  model: AIModelConfig = AI_MODELS.Gemini25Flash,
-) => {
-  const FlowInputSchema = ai.defineSchema(`${name}InputSchema`, inputSchema);
-  const FlowOutputSchema = ai.defineSchema(`${name}OutputSchema`, outputSchema);
-  const prompt = ai.prompt<
-    typeof FlowInputSchema,
-    typeof FlowOutputSchema,
-    z.ZodTypeAny
-  >(name);
-
-  return ai.defineFlow(
-    {
-      name: name,
-      inputSchema: inputSchema,
-      outputSchema: outputSchema,
-    },
-    async (input: T) => {
-      const response = await prompt(input);
-      logAIUsage({
-        type: "multimodal",
-        flowName: name,
-        model,
-        inputTokens: response.usage?.inputTokens || 0,
-        outputTokens: response.usage?.outputTokens || 0,
-      });
-      return handler(input, response.output);
-    },
-  );
-};
-
-export const createImagenFlow = <T>(
-  name: string,
-  inputSchema: z.ZodSchema<T>,
-  handler: ImageFlowHandler<T>,
-  model: AIModelConfig = AI_MODELS.Imagen4Fast,
-) => {
-  return ai.defineFlow(
-    {
-      name: name,
-      inputSchema: inputSchema,
-      outputSchema: ImagenOutputSchema,
-    },
-    async (input: T) => {
-      const imageData = await handler(input, name);
-      const uploadPromises = imageData.map(({ base64Data, storagePath }) =>
-        uploadImageToStorage(base64Data, storagePath).catch((err) => {
-          throw err;
-        }),
-      );
-      const uploadedImages = await Promise.all(uploadPromises);
-      logAIUsage({
-        type: "image",
-        flowName: name,
-        model,
-        imageCount: imageData.length,
-      });
-      return {
-        images: uploadedImages,
-      };
-    },
-  );
-};
+import { z } from "genkit";
+import { AI_MODELS } from "../../config/ai";
+import { logAIUsage } from "./cost";
+import { ai } from "./genkit";
+import { uploadImageToStorage } from "../storage";
+import { AIModelConfig } from "../../types";
+
+export const ImagenOutputSchema = z.object({
+  images: z.array(
+    z.object({
+      url: z.string(),
+      path: z.string(),
+    }),
+  ),
+});
+
+export type FlowHandler<T, R> = (input: T, output: R | null) => Promise<R>;
+export type ImageFlowHandler<T> = (
+  input: T,
+  prompt: string,
+) => Promise<{ base64Data: string; storagePath: string }[]>;
+
+export const createGeminiFlow = <T, R>(
+  name: string,
+  inputSchema: z.ZodSchema<T>,
+  outputSchema: z.ZodSchema<R>,
+  handler: FlowHandler<T, R>,
+  model: AIModelConfig = AI_MODELS.Gemini25Flash,
+) => {
+  const FlowInputSchema = ai.defineSchema(`${name}InputSchema`, inputSchema);
+  const FlowOutputSchema = ai.defineSchema(`${name}OutputSchema`, outputSchema);
+  const prompt = ai.prompt<
+    typeof FlowInputSchema,
+    typeof FlowOutputSchema,
+    z.ZodTypeAny
+  >(name);
+
+  return ai.defineFlow(
+    {
+      name: name,
+      inputSchema: inputSchema,
+      outputSchema: outputSchema,
+    },
+    async (input: T) => {
+      const response = await prompt(input);
+      logAIUsage({
+        type: "multimodal",
+        flowName: name,
+        model,
+        inputTokens: response.usage?.inputTokens || 0,
+        outputTokens: response.usage?.outputTokens || 0,
+      });
+      return handler(input, response.output);
+    },
+  );
+};
+
+export const createImagenFlow = <T>(
+  name: string,
+  inputSchema: z.ZodSchema<T>,
+  handler: ImageFlowHandler<T>,
+  model: AIModelConfig = AI_MODELS.Imagen4Fast,
+) => {
+  return ai.defineFlow(
+    {
+      name: name,
+      inputSchema: inputSchema,
+      outputSchema: ImagenOutputSchema,
+    },
+    async (input: T) => {
+      const imageData = await handler(input, name);
+      const uploadPromises = imageData.map(({ base64Data, storagePath }) =>
+        uploadImageToStorage(base64Data, storagePath).catch((err) => {
+          throw err;
+        }),
+      );
+      const uploadedImages = await Promise.all(uploadPromises);
+      logAIUsage({
+        type: "image",
+        flowName: name,
+        model,
+        imageCount: imageData.length,
+      });
+      return {
+        images: uploadedImages,
+      };
+    },
+  );
+};

package/src/lib/ai/genkit.ts

@@ -1,18 +1,24 @@
-import { genkit, EmbedderReference } from "genkit";
+import { genkit, EmbedderReference, Genkit } from "genkit";
 import { vertexAI } from "@genkit-ai/google-genai";
+import { onInit } from "firebase-functions/v2/core";
 
 const projectId =
   process.env.GCLOUD_PROJECT || process.env.GCP_PROJECT || "canary-cravery";
 
-export const ai = genkit({
-  plugins: [
-    vertexAI({
-      location: "us-central1",
-      projectId,
-    }),
-  ],
-});
+// Declare but don't initialize yet - will be initialized in onInit
+export let ai: Genkit;
+export let geminiEmbedding001: EmbedderReference;
+
+// Initialize during Firebase Functions init phase, not at module load
+onInit(() => {
+  ai = genkit({
+    plugins: [
+      vertexAI({
+        location: "us-central1",
+        projectId,
+      }),
+    ],
+  });
 
-export const geminiEmbedding001: EmbedderReference = vertexAI.embedder(
-  "gemini-embedding-001",
-);
+  geminiEmbedding001 = vertexAI.embedder("gemini-embedding-001");
+});

package/src/lib/api.ts

@@ -1,103 +1,103 @@
-import {
-  onCall,
-  HttpsError,
-  CallableRequest,
-  CallableOptions,
-} from "firebase-functions/v2/https";
-import { z } from "genkit";
-import { isAdmin, isModeratorOrAbove, isTranslatorOrAbove } from "./iam";
-
-const DEFAULT_OPTIONS: CallableOptions = { cors: true, enforceAppCheck: true };
-
-const handleError = (error: unknown): never => {
-  if (error instanceof z.ZodError) {
-    throw new HttpsError(
-      "invalid-argument",
-      `Validation failed: ${error.message}`,
-    );
-  }
-  if (error instanceof HttpsError) {
-    throw error;
-  }
-  throw new HttpsError(
-    "internal",
-    error instanceof Error ? error.message : "Unknown error",
-  );
-};
-
-class CallableBuilder<T> {
-  private requiresAuth = false;
-  private requiresAdmin = false;
-  private requiresModerator = false;
-  private requiresTranslator = false;
-  private options: CallableOptions = DEFAULT_OPTIONS;
-
-  constructor(private schema: z.ZodSchema<T>) {}
-
-  requireAdmin() {
-    this.requiresAuth = true;
-    this.requiresAdmin = true;
-    return this;
-  }
-
-  requireUser() {
-    this.requiresAuth = true;
-    return this;
-  }
-
-  requireModerator() {
-    this.requiresAuth = true;
-    this.requiresModerator = true;
-    return this;
-  }
-
-  requireTranslator() {
-    this.requiresAuth = true;
-    this.requiresTranslator = true;
-    return this;
-  }
-
-  withOptions(options: CallableOptions) {
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-    return this;
-  }
-
-  handle<R>(handler: (data: T, request: CallableRequest) => Promise<R>) {
-    return onCall(this.options, async (request) => {
-      if (this.requiresAuth && !request.auth) {
-        throw new HttpsError("unauthenticated", "Authentication required");
-      }
-
-      if (request.auth) {
-        const uid = request.auth.uid;
-
-        if (this.requiresAdmin && !(await isAdmin(uid))) {
-          throw new HttpsError("permission-denied", "Admin access required");
-        } else if (this.requiresModerator && !(await isModeratorOrAbove(uid))) {
-          throw new HttpsError(
-            "permission-denied",
-            "Moderator access required",
-          );
-        } else if (
-          this.requiresTranslator &&
-          !(await isTranslatorOrAbove(uid))
-        ) {
-          throw new HttpsError(
-            "permission-denied",
-            "Translator access required",
-          );
-        }
-      }
-
-      try {
-        const data = this.schema.parse(request.data);
-        return await handler(data, request);
-      } catch (error) {
-        throw handleError(error);
-      }
-    });
-  }
-}
-
-export const callable = <T>(schema: z.ZodSchema<T>) =>
-  new CallableBuilder(schema);
+import {
+  onCall,
+  HttpsError,
+  CallableRequest,
+  CallableOptions,
+} from "firebase-functions/v2/https";
+import { z } from "genkit";
+import { isAdmin, isModeratorOrAbove, isTranslatorOrAbove } from "./iam";
+
+const DEFAULT_OPTIONS: CallableOptions = { cors: true, enforceAppCheck: true };
+
+const handleError = (error: unknown): never => {
+  if (error instanceof z.ZodError) {
+    throw new HttpsError(
+      "invalid-argument",
+      `Validation failed: ${error.message}`,
+    );
+  }
+  if (error instanceof HttpsError) {
+    throw error;
+  }
+  throw new HttpsError(
+    "internal",
+    error instanceof Error ? error.message : "Unknown error",
+  );
+};
+
+class CallableBuilder<T> {
+  private requiresAuth = false;
+  private requiresAdmin = false;
+  private requiresModerator = false;
+  private requiresTranslator = false;
+  private options: CallableOptions = DEFAULT_OPTIONS;
+
+  constructor(private schema: z.ZodSchema<T>) {}
+
+  requireAdmin() {
+    this.requiresAuth = true;
+    this.requiresAdmin = true;
+    return this;
+  }
+
+  requireUser() {
+    this.requiresAuth = true;
+    return this;
+  }
+
+  requireModerator() {
+    this.requiresAuth = true;
+    this.requiresModerator = true;
+    return this;
+  }
+
+  requireTranslator() {
+    this.requiresAuth = true;
+    this.requiresTranslator = true;
+    return this;
+  }
+
+  withOptions(options: CallableOptions) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    return this;
+  }
+
+  handle<R>(handler: (data: T, request: CallableRequest) => Promise<R>) {
+    return onCall(this.options, async (request) => {
+      if (this.requiresAuth && !request.auth) {
+        throw new HttpsError("unauthenticated", "Authentication required");
+      }
+
+      if (request.auth) {
+        const uid = request.auth.uid;
+
+        if (this.requiresAdmin && !(await isAdmin(uid))) {
+          throw new HttpsError("permission-denied", "Admin access required");
+        } else if (this.requiresModerator && !(await isModeratorOrAbove(uid))) {
+          throw new HttpsError(
+            "permission-denied",
+            "Moderator access required",
+          );
+        } else if (
+          this.requiresTranslator &&
+          !(await isTranslatorOrAbove(uid))
+        ) {
+          throw new HttpsError(
+            "permission-denied",
+            "Translator access required",
+          );
+        }
+      }
+
+      try {
+        const data = this.schema.parse(request.data);
+        return await handler(data, request);
+      } catch (error) {
+        throw handleError(error);
+      }
+    });
+  }
+}
+
+export const callable = <T>(schema: z.ZodSchema<T>) =>
+  new CallableBuilder(schema);

package/src/lib/utils/sanitize.ts

@@ -1,38 +1,38 @@
-import { z } from "genkit";
-
-/**
- * Removes HTML tags and script content from a string.
- * Use for text fields that should not contain HTML (descriptions, bios, etc.)
- */
-export function sanitizeText(text: string): string {
-  return text
-    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
-    .replace(/<[^>]*>/g, "")
-    .trim();
-}
-
-/**
- * Creates a Zod string schema that sanitizes HTML on transformation.
- * Use in schemas where text input needs to be cleaned.
- *
- * @example
- * const BioSchema = sanitizedString(z.string().max(280));
- */
-export function sanitizedString<T extends z.ZodString>(schema: T) {
-  return schema.transform(sanitizeText);
-}
-
-/**
- * Escapes HTML special characters to prevent XSS.
- * Use when HTML needs to be displayed as text.
- */
-export function escapeHtml(text: string): string {
-  const htmlEscapes: Record<string, string> = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-  };
-  return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
-}
+import { z } from "genkit";
+
+/**
+ * Removes HTML tags and script content from a string.
+ * Use for text fields that should not contain HTML (descriptions, bios, etc.)
+ */
+export function sanitizeText(text: string): string {
+  return text
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
+    .replace(/<[^>]*>/g, "")
+    .trim();
+}
+
+/**
+ * Creates a Zod string schema that sanitizes HTML on transformation.
+ * Use in schemas where text input needs to be cleaned.
+ *
+ * @example
+ * const BioSchema = sanitizedString(z.string().max(280));
+ */
+export function sanitizedString<T extends z.ZodString>(schema: T) {
+  return schema.transform(sanitizeText);
+}
+
+/**
+ * Escapes HTML special characters to prevent XSS.
+ * Use when HTML needs to be displayed as text.
+ */
+export function escapeHtml(text: string): string {
+  const htmlEscapes: Record<string, string> = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+  };
+  return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}

package/src/types/ai/recipe.ts

@@ -1,61 +1,68 @@
-import { z } from "genkit";
-import {
-  AllergenSchema,
-  CuisineSchema,
-  DietaryTagSchema,
-  DifficultySchema,
-  EquipmentSchema,
-  IngredientSectionSchema,
-  InstructionSchema,
-  MealTypeSchema,
-  NutritionSchema,
-  SpicinessSchema,
-  type Allergen,
-  type Cuisine,
-  type DietaryTag,
-  type Difficulty,
-  type Equipment,
-  type IngredientSection,
-  type Instruction,
-  type MealType,
-  type Nutrition,
-  type Spiciness,
-} from "../recipe";
-
-export interface AIRecipe {
-  allergens: Allergen[];
-  confidence: number;
-  cuisine: Cuisine;
-  description: string;
-  dietaryTags: DietaryTag[];
-  difficulty: Difficulty;
-  equipment?: Equipment[];
-  ingredientSections: IngredientSection[];
-  instructions: Instruction[];
-  mealTypes: MealType[];
-  nutrition?: Nutrition;
-  servings: number;
-  spiciness: Spiciness;
-  time: number;
-  tips?: string[];
-  title: string;
-}
-
-export const AIRecipeSchema = z.object({
-  allergens: z.array(AllergenSchema),
-  confidence: z.number().min(0).max(1),
-  cuisine: CuisineSchema,
-  description: z.string().min(10).max(2000),
-  dietaryTags: z.array(DietaryTagSchema),
-  difficulty: DifficultySchema,
-  equipment: z.array(EquipmentSchema).max(20).optional(),
-  ingredientSections: z.array(IngredientSectionSchema).min(1).max(10),
-  instructions: z.array(InstructionSchema).min(1).max(50),
-  mealTypes: z.array(MealTypeSchema).min(1),
-  nutrition: NutritionSchema.optional(),
-  servings: z.number().int().min(1).max(100),
-  spiciness: SpicinessSchema,
-  time: z.number().int().min(1).max(1440),
-  tips: z.array(z.string().max(500)).max(10).optional(),
-  title: z.string().min(3).max(200),
-}) satisfies z.ZodType<AIRecipe>;
+import { z } from "genkit";
+import {
+  AllergenSchema,
+  CuisineSchema,
+  DietaryTagSchema,
+  DifficultySchema,
+  EquipmentSchema,
+  IngredientSectionSchema,
+  InstructionSchema,
+  MealTypeSchema,
+  NutritionSchema,
+  SpicinessSchema,
+  type Allergen,
+  type Cuisine,
+  type DietaryTag,
+  type Difficulty,
+  type Equipment,
+  type IngredientSection,
+  type Instruction,
+  type MealType,
+  type Nutrition,
+  type Spiciness,
+} from "../recipe";
+
+export interface AIRecipe {
+  allergens: Allergen[];
+  confidence: number;
+  cuisine: Cuisine;
+  description: string;
+  dietaryTags: DietaryTag[];
+  difficulty: Difficulty;
+  equipment?: Equipment[];
+  ingredientSections: IngredientSection[];
+  instructions: Instruction[];
+  mealTypes: MealType[];
+  nutrition?: Nutrition;
+  servings: number;
+  spiciness: Spiciness;
+  time: number;
+  tips?: string[];
+  title: string;
+}
+
+// Simplified schema for Gemini structured output
+// Removed complex constraints that cause "too many states" errors:
+// - Regex patterns on slugs (removed from nested schemas)
+// - High array max limits (instructions max 50, equipment max 20, etc)
+// - Numeric min/max bounds (confidence 0-1, servings 1-100, time 1-1440, etc)
+// - String length constraints (description 10-2000, title 3-200, etc)
+// These validations should be done in application logic if needed
+export const AIRecipeSchema = z.object({
+  allergens: z.array(AllergenSchema),
+  confidence: z.number(),
+  cuisine: CuisineSchema,
+  description: z.string(),
+  dietaryTags: z.array(DietaryTagSchema),
+  difficulty: DifficultySchema,
+  equipment: z.array(EquipmentSchema).optional(),
+  ingredientSections: z.array(IngredientSectionSchema),
+  instructions: z.array(InstructionSchema),
+  mealTypes: z.array(MealTypeSchema),
+  nutrition: NutritionSchema.optional(),
+  servings: z.number(),
+  spiciness: SpicinessSchema,
+  time: z.number(),
+  tips: z.array(z.string()).optional(),
+  title: z.string(),
+}) satisfies z.ZodType<AIRecipe>;