@cravery/core 0.0.2 → 0.0.3

package/src/lib/cost.ts

@@ -0,0 +1,72 @@
+import { getDatabase, ServerValue } from "firebase-admin/database";
+import { AIModelConfig } from "../types";
+
+interface BaseUsage {
+  flowName: string;
+  model: AIModelConfig;
+}
+
+interface MultimodalUsage extends BaseUsage {
+  type: "multimodal";
+  inputTokens: number;
+  outputTokens: number;
+}
+
+interface ImageUsage extends BaseUsage {
+  type: "image";
+  imageCount: number;
+}
+
+interface EmbeddingUsage extends BaseUsage {
+  type: "embedding";
+  tokenCount: number;
+}
+
+export type AIUsage = MultimodalUsage | ImageUsage | EmbeddingUsage;
+
+export const logAIUsage = (usage: AIUsage): number => {
+  const { flowName, model } = usage;
+
+  let cost: number;
+  let metrics: Record<string, number>;
+
+  switch (usage.type) {
+    case "multimodal":
+      cost =
+        (usage.inputTokens / 1_000_000) * model.cost.input +
+        (usage.outputTokens / 1_000_000) * model.cost.output;
+      metrics = {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+      };
+      break;
+    case "image":
+      cost = usage.imageCount * model.cost.output;
+      metrics = { images: usage.imageCount };
+      break;
+    case "embedding":
+      cost = (usage.tokenCount / 1_000) * model.cost.input;
+      metrics = { tokens: usage.tokenCount };
+      break;
+  }
+
+  const db = getDatabase();
+  const date = new Date().toISOString().split("T")[0];
+  const base = `ai_usage/live/${date}`;
+
+  const updates: Record<string, unknown> = {
+    [`${base}/total`]: ServerValue.increment(cost),
+    [`${base}/count`]: ServerValue.increment(1),
+    [`${base}/flows/${flowName}/cost`]: ServerValue.increment(cost),
+    [`${base}/flows/${flowName}/count`]: ServerValue.increment(1),
+    [`${base}/models/${model.id}/cost`]: ServerValue.increment(cost),
+  };
+
+  for (const [key, value] of Object.entries(metrics)) {
+    updates[`${base}/models/${model.id}/${key}`] = ServerValue.increment(value);
+  }
+
+  db.ref().update(updates).catch(console.error);
+
+  return cost;
+};

package/src/lib/embedding.ts

@@ -0,0 +1,53 @@
+import { FieldValue } from "firebase-admin/firestore";
+import { defineFirestoreRetriever } from "@genkit-ai/firebase";
+import { firestore } from "./firebase";
+import { ai, geminiEmbedding001 } from "./genkit";
+import { logAIUsage } from "./cost";
+import { AI_MODELS } from "../config/ai";
+
+export const generateEmbedding = async (text: string, flowName: string) => {
+  if (text.length < 1 || text.length > 7500) {
+    throw new Error("Validation error: Text out of range");
+  }
+  const response = await ai.embed({
+    embedder: geminiEmbedding001,
+    content: text,
+  });
+  logAIUsage({
+    type: "embedding",
+    flowName,
+    model: AI_MODELS.GeminiEmbedding001,
+    tokenCount: text.length,
+  });
+  return response[0]?.embedding;
+};
+
+export const storeEmbedding = async (
+  collection: string,
+  docId: string,
+  text: string,
+  flowName?: string,
+  vectorField: string = "embedding",
+) => {
+  const embedding = await generateEmbedding(
+    text,
+    flowName || `${collection}:embedding`,
+  );
+  await firestore
+    .collection(collection)
+    .doc(docId)
+    .update({
+      [vectorField]: FieldValue.vector(embedding),
+    });
+};
+
+export const recipesRetriever = defineFirestoreRetriever(ai, {
+  name: "recipesRetriever",
+  firestore,
+  collection: "recipes",
+  contentField: "searchTerms",
+  vectorField: "titleEmbedding",
+  embedder: geminiEmbedding001,
+  distanceMeasure: "COSINE",
+  distanceResultField: "distance",
+});

package/src/lib/firebase.ts

@@ -0,0 +1,5 @@
+import { getFirestore } from "firebase-admin/firestore";
+import { getDatabase } from "firebase-admin/database";
+
+export const firestore = getFirestore();
+export const rtdb = getDatabase();

package/src/lib/flow.ts

@@ -0,0 +1,88 @@
+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/genkit.ts

@@ -0,0 +1,18 @@
+import { genkit, EmbedderReference } from "genkit";
+import { vertexAI } from "@genkit-ai/google-genai";
+
+const projectId =
+  process.env.GCLOUD_PROJECT || process.env.GCP_PROJECT || "canary-cravery";
+
+export const ai = genkit({
+  plugins: [
+    vertexAI({
+      location: "us-central1",
+      projectId,
+    }),
+  ],
+});
+
+export const geminiEmbedding001: EmbedderReference = vertexAI.embedder(
+  "gemini-embedding-001",
+);

package/src/lib/iam.ts

@@ -0,0 +1,22 @@
+import * as admin from "firebase-admin";
+import { Role } from "../enums";
+
+const getUserRole = async (uid: string): Promise<Role> => {
+  let role: Role = "guest";
+  const userDoc = await admin.firestore().collection("users").doc(uid).get();
+  if (userDoc.exists) {
+    const userData = userDoc.data();
+    role = userData?.role || "user";
+  }
+  return role;
+};
+
+export const isAdmin = async (uid: string): Promise<boolean> => {
+  const role = await getUserRole(uid);
+  return role === "admin";
+};
+
+export const isModerator = async (uid: string): Promise<boolean> => {
+  const role = await getUserRole(uid);
+  return role === "admin" || role === "moderator";
+};

package/src/lib/image.ts

@@ -0,0 +1,28 @@
+import type { GenerateResponse } from "genkit";
+import { AIFlowError } from "../types";
+
+export interface ImageData {
+  base64: string;
+  contentType: string;
+}
+
+export const getImageData = (response: GenerateResponse): ImageData => {
+  const media = response.media;
+
+  if (!media?.url) {
+    throw new AIFlowError("model_error", "No image data in response", [
+      "Try with a different recipe description",
+    ]);
+  }
+
+  const url = media.url;
+  const contentType = media.contentType ?? "image/png";
+
+  // Extract base64 from data URI if present
+  if (url.startsWith("data:")) {
+    const base64Part = url.split(",")[1];
+    if (base64Part) return { base64: base64Part, contentType };
+  }
+
+  return { base64: url, contentType };
+};

package/src/lib/index.ts

@@ -0,0 +1,9 @@
+export * from "./api";
+export * from "./cost";
+export * from "./embedding";
+export * from "./firebase";
+export * from "./flow";
+export * from "./genkit";
+export * from "./iam";
+export * from "./image";
+export * from "./storage";

package/src/lib/storage.ts

@@ -0,0 +1,42 @@
+import { getStorage } from "firebase-admin/storage";
+
+export interface UploadImageResult {
+  url: string;
+  path: string;
+}
+
+export const uploadImageToStorage = async (
+  base64Data: string,
+  path: string,
+  contentType: string = "image/png",
+): Promise<UploadImageResult> => {
+  try {
+    const bucket = getStorage().bucket();
+    const buffer = Buffer.from(base64Data, "base64");
+    const file = bucket.file(path);
+
+    const fileExists = await file.exists();
+    if (fileExists[0]) {
+      await file.delete();
+    }
+
+    await file.save(buffer, {
+      metadata: {
+        contentType,
+        cacheControl: "public",
+      },
+      resumable: false,
+    });
+
+    const publicUrl = `https://storage.googleapis.com/${bucket.name}/${path}`;
+
+    return {
+      url: publicUrl,
+      path,
+    };
+  } catch {
+    const uploadError = new Error("Image upload failed");
+    uploadError.name = "UPLOAD_FAILED";
+    throw uploadError;
+  }
+};

package/src/types/ai/config.ts

@@ -1,14 +1,15 @@
 /**
  * AI model configuration, costs are in USD:
  * - multimodal: cost per 1,000,000 input/output tokens
- * - image: cost per image
+ * - image: cost per image (stored in cost.output)
  * - embedding: cost per 1,000 input tokens
  */
 export type AIModel =
   | "Gemini25Flash"
   | "Gemini25Pro"
+  | "Gemini3Flash"
   | "Imagen4Fast"
-  | "TextEmbedding005";
+  | "GeminiEmbedding001";
 export type AIModelType = "multimodal" | "image" | "embedding";
 
 export interface AIModelCost {

package/src/types/equipment.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { SlugRegex } from "../config";
 
 export const EquipmentMetaSchema = z.object({
-  optional: z.boolean().optional(),
+  required: z.boolean().optional(),
   slug: z.string().regex(SlugRegex),
 });
 export type EquipmentMeta = z.infer<typeof EquipmentMetaSchema>;

package/src/types/error.ts

@@ -0,0 +1,43 @@
+export const AI_ERROR_CODE_VALUES = [
+  "hallucination_detected",
+  "image_unclear",
+  "impossible_constraint",
+  "invalid_input",
+  "invalid_url",
+  "low_confidence",
+  "model_error",
+  "no_recipe_found",
+  "nonsense_input",
+  "rate_limit",
+  "timeout",
+  "translation_failed",
+  "unsafe_input",
+  "url_not_accessible",
+] as const;
+
+export type AIErrorCode = (typeof AI_ERROR_CODE_VALUES)[number];
+
+export class AIFlowError extends Error {
+  public readonly code: AIErrorCode;
+  public readonly suggestions?: string[];
+
+  constructor(code: AIErrorCode, message: string, suggestions?: string[]) {
+    super(message);
+    this.name = "AIFlowError";
+    this.code = code;
+    this.suggestions = suggestions;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, AIFlowError);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      suggestions: this.suggestions,
+    };
+  }
+}

package/src/types/index.ts

@@ -1,5 +1,6 @@
 export * from "./ai";
 export * from "./equipment";
+export * from "./error";
 export * from "./ingredient";
 export * from "./instruction";
 export * from "./moderation";

package/src/types/ingredient.ts

@@ -3,8 +3,8 @@ import { SlugRegex } from "../config";
 import { UnitSchema } from "../enums";
 
 export const IngredientMetaSchema = z.object({
-  optional: z.boolean().optional(),
   quantity: z.number().positive().optional(),
+  required: z.boolean().optional(),
   slug: z.string().regex(SlugRegex),
   unit: UnitSchema.optional(),
 });