@weirdfingers/baseboards 0.2.1 → 0.4.0

package/templates/api/src/boards/workers/context.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from uuid import UUID
+from uuid import UUID, uuid4
 
 from ..database.connection import get_async_session
 from ..generators import resolution
@@ -24,12 +24,22 @@ class GeneratorExecutionContext:
         storage_manager: StorageManager,
         tenant_id: UUID,
         board_id: UUID,
+        user_id: UUID,
+        generator_name: str,
+        artifact_type: str,
+        input_params: dict,
     ) -> None:
         self.generation_id = str(generation_id)
         self.publisher = publisher
         self.storage_manager = storage_manager
         self.tenant_id = str(tenant_id)
         self.board_id = str(board_id)
+        self.user_id = str(user_id)
+        self.generator_name = generator_name
+        self.artifact_type = artifact_type
+        self.input_params = input_params
+        self._batch_id: str | None = None
+        self._batch_generations: list[str] = []
         logger.info(
             "Created execution context",
             generation_id=str(generation_id),
@@ -52,15 +62,34 @@ class GeneratorExecutionContext:
         self,
         storage_url: str,
         format: str,
-        width: int,
-        height: int,
+        width: int | None = None,
+        height: int | None = None,
+        output_index: int = 0,
     ) -> ImageArtifact:
-        """Store image generation result."""
-        logger.debug("Storing image result", generation_id=self.generation_id)
+        """Store image generation result.
+
+        Args:
+            storage_url: URL to download the image from
+            format: Image format (png, jpg, etc.)
+            width: Image width in pixels (optional)
+            height: Image height in pixels (optional)
+            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
+
+        Returns:
+            ImageArtifact with the generation_id set appropriately
+        """
+        logger.debug(
+            "Storing image result",
+            generation_id=self.generation_id,
+            output_index=output_index,
+        )
         try:
+            # Determine which generation_id to use
+            target_generation_id = await self._get_or_create_generation_for_output(output_index)
+
             result = await resolution.store_image_result(
                 storage_manager=self.storage_manager,
-                generation_id=self.generation_id,
+                generation_id=target_generation_id,
                 tenant_id=self.tenant_id,
                 board_id=self.board_id,
                 storage_url=storage_url,
@@ -68,7 +97,11 @@ class GeneratorExecutionContext:
                 width=width,
                 height=height,
             )
-            logger.info("Image result stored", generation_id=self.generation_id)
+            logger.info(
+                "Image result stored",
+                generation_id=target_generation_id,
+                output_index=output_index,
+            )
             return result
         except Exception as e:
             logger.error("Failed to store image result", error=str(e))
@@ -78,17 +111,38 @@ class GeneratorExecutionContext:
         self,
         storage_url: str,
         format: str,
-        width: int,
-        height: int,
+        width: int | None = None,
+        height: int | None = None,
         duration: float | None = None,
         fps: float | None = None,
+        output_index: int = 0,
     ) -> VideoArtifact:
-        """Store video generation result."""
-        logger.debug("Storing video result", generation_id=self.generation_id)
+        """Store video generation result.
+
+        Args:
+            storage_url: URL to download the video from
+            format: Video format (mp4, webm, etc.)
+            width: Video width in pixels (optional)
+            height: Video height in pixels (optional)
+            duration: Video duration in seconds (optional)
+            fps: Frames per second (optional)
+            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
+
+        Returns:
+            VideoArtifact with the generation_id set appropriately
+        """
+        logger.debug(
+            "Storing video result",
+            generation_id=self.generation_id,
+            output_index=output_index,
+        )
         try:
+            # Determine which generation_id to use
+            target_generation_id = await self._get_or_create_generation_for_output(output_index)
+
             result = await resolution.store_video_result(
                 storage_manager=self.storage_manager,
-                generation_id=self.generation_id,
+                generation_id=target_generation_id,
                 tenant_id=self.tenant_id,
                 board_id=self.board_id,
                 storage_url=storage_url,
@@ -98,7 +152,11 @@ class GeneratorExecutionContext:
                 duration=duration,
                 fps=fps,
             )
-            logger.info("Video result stored", generation_id=self.generation_id)
+            logger.info(
+                "Video result stored",
+                generation_id=target_generation_id,
+                output_index=output_index,
+            )
             return result
         except Exception as e:
             logger.error("Failed to store video result", error=str(e))
@@ -111,13 +169,33 @@ class GeneratorExecutionContext:
         duration: float | None = None,
         sample_rate: int | None = None,
         channels: int | None = None,
+        output_index: int = 0,
     ) -> AudioArtifact:
-        """Store audio generation result."""
-        logger.debug("Storing audio result", generation_id=self.generation_id)
+        """Store audio generation result.
+
+        Args:
+            storage_url: URL to download the audio from
+            format: Audio format (mp3, wav, etc.)
+            duration: Audio duration in seconds (optional)
+            sample_rate: Sample rate in Hz (optional)
+            channels: Number of audio channels (optional)
+            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
+
+        Returns:
+            AudioArtifact with the generation_id set appropriately
+        """
+        logger.debug(
+            "Storing audio result",
+            generation_id=self.generation_id,
+            output_index=output_index,
+        )
         try:
+            # Determine which generation_id to use
+            target_generation_id = await self._get_or_create_generation_for_output(output_index)
+
             result = await resolution.store_audio_result(
                 storage_manager=self.storage_manager,
-                generation_id=self.generation_id,
+                generation_id=target_generation_id,
                 tenant_id=self.tenant_id,
                 board_id=self.board_id,
                 storage_url=storage_url,
@@ -126,7 +204,11 @@ class GeneratorExecutionContext:
                 sample_rate=sample_rate,
                 channels=channels,
             )
-            logger.info("Audio result stored", generation_id=self.generation_id)
+            logger.info(
+                "Audio result stored",
+                generation_id=target_generation_id,
+                output_index=output_index,
+            )
             return result
         except Exception as e:
             logger.error("Failed to store audio result", error=str(e))
@@ -136,19 +218,40 @@ class GeneratorExecutionContext:
         self,
         content: str,
         format: str,
+        output_index: int = 0,
     ) -> TextArtifact:
-        """Store text generation result."""
-        logger.debug("Storing text result", generation_id=self.generation_id)
+        """Store text generation result.
+
+        Args:
+            content: Text content to store
+            format: Text format (plain, markdown, html, etc.)
+            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
+
+        Returns:
+            TextArtifact with the generation_id set appropriately
+        """
+        logger.debug(
+            "Storing text result",
+            generation_id=self.generation_id,
+            output_index=output_index,
+        )
         try:
+            # Determine which generation_id to use
+            target_generation_id = await self._get_or_create_generation_for_output(output_index)
+
             result = await resolution.store_text_result(
                 storage_manager=self.storage_manager,
-                generation_id=self.generation_id,
+                generation_id=target_generation_id,
                 tenant_id=self.tenant_id,
                 board_id=self.board_id,
                 content=content,
                 format=format,
             )
-            logger.info("Text result stored", generation_id=self.generation_id)
+            logger.info(
+                "Text result stored",
+                generation_id=target_generation_id,
+                output_index=output_index,
+            )
             return result
         except Exception as e:
             logger.error("Failed to store text result", error=str(e))
@@ -186,3 +289,56 @@ class GeneratorExecutionContext:
         )
         async with get_async_session() as session:
             await jobs_repo.set_external_job_id(session, self.generation_id, external_id)
+
+    async def _get_or_create_generation_for_output(self, output_index: int) -> str:
+        """Get or create a generation record for the given output index.
+
+        Args:
+            output_index: Index of the output (0 for primary, 1+ for batch outputs)
+
+        Returns:
+            generation_id to use for storing this output
+        """
+        # Index 0 is always the primary generation
+        if output_index == 0:
+            return self.generation_id
+
+        # For batch outputs, ensure we have a batch_id
+        if self._batch_id is None:
+            self._batch_id = str(uuid4())
+            logger.debug(
+                "Created batch_id for multi-output generation",
+                batch_id=self._batch_id,
+                primary_generation_id=self.generation_id,
+            )
+
+        # Check if we've already created a generation for this index
+        batch_index = output_index - 1  # Adjust since index 0 is primary
+        if batch_index < len(self._batch_generations):
+            return self._batch_generations[batch_index]
+
+        # Create new batch generation record
+        async with get_async_session() as session:
+            batch_gen = await jobs_repo.create_batch_generation(
+                session,
+                tenant_id=UUID(self.tenant_id),
+                board_id=UUID(self.board_id),
+                user_id=UUID(self.user_id),
+                generator_name=self.generator_name,
+                artifact_type=self.artifact_type,
+                input_params=self.input_params,
+                batch_id=self._batch_id,
+                batch_index=output_index,
+            )
+            await session.commit()
+            batch_gen_id = str(batch_gen.id)
+
+        self._batch_generations.append(batch_gen_id)
+        logger.info(
+            "Created batch generation record",
+            batch_generation_id=batch_gen_id,
+            primary_generation_id=self.generation_id,
+            batch_id=self._batch_id,
+            batch_index=output_index,
+        )
+        return batch_gen_id

package/templates/web/package.json

@@ -10,10 +10,11 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@radix-ui/react-navigation-menu": "^1.2.14",
     "@radix-ui/react-slot": "^1.2.3",
     "@tailwindcss/postcss": "^4.1.13",
-    "@weirdfingers/boards": "^0.2.1",
+    "@weirdfingers/boards": "^0.4.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.0.0",
     "graphql": "^16.11.0",

package/templates/web/src/components/boards/GenerationInput.tsx

@@ -1,8 +1,12 @@
 "use client";
 
-import { useState } from "react";
+import { useState, useMemo, useEffect } from "react";
 import { Settings, ArrowUp, X } from "lucide-react";
 import Image from "next/image";
+import {
+  ParsedGeneratorSchema,
+  parseGeneratorSchema,
+} from "@weirdfingers/boards";
 import { GeneratorSelector, GeneratorInfo } from "./GeneratorSelector";
 import { ArtifactInputSlots } from "./ArtifactInputSlots";
 
@@ -13,12 +17,6 @@ interface Generation {
   thumbnailUrl?: string | null;
 }
 
-interface ArtifactSlot {
-  name: string;
-  type: string;
-  required: boolean;
-}
-
 interface GenerationInputProps {
   generators: GeneratorInfo[];
   availableArtifacts: Generation[];
@@ -45,53 +43,42 @@ export function GenerationInput({
   >(new Map());
   const [attachedImage, setAttachedImage] = useState<Generation | null>(null);
   const [showSettings, setShowSettings] = useState(false);
+  const [settings, setSettings] = useState<Record<string, unknown>>({});
 
-  // Parse input schema to determine if this generator needs artifact inputs
-  const getArtifactSlots = (): ArtifactSlot[] => {
-    if (!selectedGenerator) return [];
-
-    const schema = selectedGenerator.inputSchema as {
-      properties?: Record<
-        string,
-        {
-          type?: string;
-          anyOf?: Array<{ $ref?: string }>;
-          description?: string;
-        }
-      >;
-      required?: string[];
-    };
-
-    if (!schema.properties) return [];
-
-    const slots: ArtifactSlot[] = [];
-
-    for (const [key, value] of Object.entries(schema.properties)) {
-      // Check if this property references an artifact type
-      const isArtifact =
-        value.anyOf?.some((ref) => ref.$ref?.includes("Artifact")) || false;
-
-      if (isArtifact) {
-        // Determine artifact type from the key or description
-        let type = "video";
-        if (key.toLowerCase().includes("audio")) type = "audio";
-        if (key.toLowerCase().includes("video")) type = "video";
-        if (key.toLowerCase().includes("image")) type = "image";
-
-        slots.push({
-          name: key,
-          type,
-          required: schema.required?.includes(key) || false,
-        });
-      }
+  // Parse input schema using the toolkit's schema parser
+  const parsedSchema = useMemo((): ParsedGeneratorSchema => {
+    if (!selectedGenerator) {
+      return { artifactSlots: [], promptField: null, settingsFields: [] };
     }
+    return parseGeneratorSchema(selectedGenerator.inputSchema);
+  }, [selectedGenerator]);
 
-    return slots;
-  };
+  const artifactSlots = useMemo(() => {
+    return parsedSchema.artifactSlots.map((slot) => ({
+      name: slot.fieldName,
+      type: slot.artifactType,
+      required: slot.required,
+    }));
+  }, [parsedSchema.artifactSlots]);
 
-  const artifactSlots = getArtifactSlots();
   const needsArtifactInputs = artifactSlots.length > 0;
 
+  // Initialize settings with defaults when generator changes
+  const defaultSettings = useMemo(() => {
+    const defaults: Record<string, unknown> = {};
+    parsedSchema.settingsFields.forEach((field) => {
+      if (field.default !== undefined) {
+        defaults[field.fieldName] = field.default;
+      }
+    });
+    return defaults;
+  }, [parsedSchema.settingsFields]);
+
+  // Reset settings when generator changes or defaultSettings change
+  useEffect(() => {
+    setSettings(defaultSettings);
+  }, [selectedGenerator, defaultSettings]);
+
   const handleSubmit = () => {
     if (!selectedGenerator || !prompt.trim()) return;
 
@@ -99,13 +86,14 @@ export function GenerationInput({
       generatorName: selectedGenerator.name,
       prompt: prompt.trim(),
       artifacts: selectedArtifacts,
-      settings: {},
+      settings,
     });
 
     // Reset form
     setPrompt("");
     setSelectedArtifacts(new Map());
     setAttachedImage(null);
+    setSettings(defaultSettings);
   };
 
   const handleSelectArtifact = (
@@ -241,9 +229,123 @@ export function GenerationInput({
       {/* Settings panel (collapsed by default) */}
       {showSettings && (
         <div className="px-4 py-4 border-t border-gray-200 bg-gray-50">
-          <p className="text-sm text-gray-600">
-            Generator-specific settings will appear here
-          </p>
+          {parsedSchema.settingsFields.length === 0 ? (
+            <p className="text-sm text-gray-600">
+              No additional settings available for this generator
+            </p>
+          ) : (
+            <div>
+              <h3 className="text-sm font-medium text-gray-900 mb-4">
+                Generator Settings
+              </h3>
+              <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              {parsedSchema.settingsFields.map((field) => (
+                <div key={field.fieldName} className="space-y-1.5">
+                  <label
+                    htmlFor={field.fieldName}
+                    className="block text-sm font-medium text-gray-700"
+                  >
+                    {field.title}
+                  </label>
+                  {field.description && (
+                    <p className="text-xs text-gray-500">{field.description}</p>
+                  )}
+
+                  {/* Slider control */}
+                  {field.type === "slider" && (
+                    <div className="space-y-1">
+                      <input
+                        id={field.fieldName}
+                        type="range"
+                        min={field.min}
+                        max={field.max}
+                        step={field.step || (field.isInteger ? 1 : 0.01)}
+                        value={
+                          (settings[field.fieldName] as number) ?? field.default
+                        }
+                        onChange={(e) =>
+                          setSettings({
+                            ...settings,
+                            [field.fieldName]: field.isInteger
+                              ? parseInt(e.target.value)
+                              : parseFloat(e.target.value),
+                          })
+                        }
+                        className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer accent-orange-500"
+                      />
+                      <div className="flex justify-between text-xs text-gray-600">
+                        <span>{field.min}</span>
+                        <span className="font-medium">
+                          {String(settings[field.fieldName] ?? field.default ?? field.min)}
+                        </span>
+                        <span>{field.max}</span>
+                      </div>
+                    </div>
+                  )}
+
+                  {/* Dropdown control */}
+                  {field.type === "dropdown" && (
+                    <select
+                      id={field.fieldName}
+                      value={(settings[field.fieldName] as string) ?? field.default}
+                      onChange={(e) =>
+                        setSettings({
+                          ...settings,
+                          [field.fieldName]: e.target.value,
+                        })
+                      }
+                      className="block w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-orange-500"
+                    >
+                      {field.options.map((option) => (
+                        <option key={option} value={option}>
+                          {option}
+                        </option>
+                      ))}
+                    </select>
+                  )}
+
+                  {/* Number input control */}
+                  {field.type === "number" && (
+                    <input
+                      id={field.fieldName}
+                      type="number"
+                      min={field.min}
+                      max={field.max}
+                      step={field.isInteger ? 1 : "any"}
+                      value={(settings[field.fieldName] as number) ?? field.default}
+                      onChange={(e) =>
+                        setSettings({
+                          ...settings,
+                          [field.fieldName]: field.isInteger
+                            ? parseInt(e.target.value)
+                            : parseFloat(e.target.value),
+                        })
+                      }
+                      className="block w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-orange-500"
+                    />
+                  )}
+
+                  {/* Text input control */}
+                  {field.type === "text" && (
+                    <input
+                      id={field.fieldName}
+                      type="text"
+                      value={(settings[field.fieldName] as string) ?? field.default ?? ""}
+                      onChange={(e) =>
+                        setSettings({
+                          ...settings,
+                          [field.fieldName]: e.target.value,
+                        })
+                      }
+                      pattern={field.pattern}
+                      className="block w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-orange-500"
+                    />
+                  )}
+                </div>
+              ))}
+              </div>
+            </div>
+          )}
         </div>
       )}
     </div>