Initial commit

.env.example

@@ -0,0 +1,9 @@
+# Hugging Face token for downloading models
+HF_TOKEN=your_huggingface_token_here
+
+# Model configuration
+MODEL_ID=meta-llama/Llama-3.2-3B-Instruct
+
+# Application IDs
+TEXT_TO_IMAGE_APP_ID=c25dcd829d134ea98f5ae4dd311d13bc.node3.openfabric.network
+IMAGE_TO_3D_APP_ID=f0b5f319156c4819b9827000b17e511a.node3.openfabric.network

.env.spaces

@@ -0,0 +1,18 @@
+# Environment variables for Hugging Face Spaces deployment
+HTTPX_VERIFY=0
+UI_PORT=7860
+HF_SPACES=1
+
+# Openfabric App IDs
+TEXT_TO_IMAGE_APP_ID=c25dcd829d134ea98f5ae4dd311d13bc.node3.openfabric.network
+IMAGE_TO_3D_APP_ID=f0b5f319156c4819b9827000b17e511a.node3.openfabric.network
+
+# LLM Configuration for Spaces - use a hosted model instead of local files
+MODEL_ID=meta-llama/Llama-3.2-3B-Instruct
+
+# Data Directories (Spaces-friendly paths)
+IMAGE_OUTPUT_DIR=/tmp/data/images
+MODEL_OUTPUT_DIR=/tmp/data/models
+
+# Log level
+LOG_LEVEL=INFO

.gitattributes

@@ -1,6 +1,13 @@
+*.glb filter=lfs diff=lfs merge=lfs -text
+*.gltf filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.gguf filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+app/llm/models/** filter=lfs diff=lfs merge=lfs -text
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
 *.ckpt filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
@@ -13,16 +20,13 @@
 *.msgpack filter=lfs diff=lfs merge=lfs -text
 *.npy filter=lfs diff=lfs merge=lfs -text
 *.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
 *.pickle filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
 *.tar filter=lfs diff=lfs merge=lfs -text
@@ -34,5 +38,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
-*.glb filter=lfs diff=lfs merge=lfs -text
-*.gltf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,57 @@
+
+# Data directories with large files
+app/data/images/*.png
+app/data/images/*.jpg
+app/data/images/*.json
+app/data/models/*.glb
+app/data/models/*.gltf
+app/data/models/*.json
+app/data/downloads/*
+
+# Exclude LLM models directory (contains large 12.8GB model)
+app/llm/models/**
+
+# Keep directory structure
+!app/data/images/.gitkeep
+!app/data/models/.gitkeep
+!app/data/downloads/.gitkeep
+!app/llm/models/.gitkeep
+
+# Python artifacts
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+
+# VS Code settings
+.vscode/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Logs
+*.log
+*.out

README.md

@@ -1,13 +1,35 @@
----
-title: Ai Creative Studio
-emoji: 🔥
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 5.25.2
-app_file: app.py
-pinned: false
-short_description: A Text - Image - 3D Model generation application
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Creative Studio
+
+An AI-powered creative application that combines text-to-image and image-to-3D model generation.
+
+## Features
+
+- Text-to-Image generation using Openfabric AI services
+- Image-to-3D model conversion
+- Interactive UI built with Gradio 4.44
+- Support for local LLM integration for prompt enhancement
+
+## Setup and Usage
+
+### Local Development
+
+1. Clone this repository
+2. Copy `.env.example` to `.env` and configure your environment variables
+3. Install dependencies: `pip install -r requirements.txt`
+4. Run the UI: `python app/ui/app.py`
+
+### Hugging Face Spaces Deployment
+
+This project is configured to run on Hugging Face Spaces. The main entry point for Spaces is the root `app.py` file.
+
+## Environment Variables
+
+Key environment variables:
+
+- `TEXT_TO_IMAGE_APP_ID`: Openfabric service ID for text-to-image generation
+- `IMAGE_TO_3D_APP_ID`: Openfabric service ID for image-to-3D conversion
+- `HF_TOKEN`: Hugging Face token for accessing models (optional in Spaces if using public models)
+
+## License
+
+This project is licensed under the MIT License.

app.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+"""
+AI Creative Studio - Hugging Face Spaces Entry Point
+"""
+
+import os
+import sys
+import logging
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("huggingface-spaces")
+
+# Make sure app directory is in the path
+app_dir = Path(__file__).parent / "app"
+sys.path.append(str(app_dir))
+
+# Set environment variables for Spaces
+os.environ["HTTPX_VERIFY"] = "0"
+os.environ["UI_PORT"] = "7860"  # Standard Spaces port
+os.environ["HF_SPACES"] = "1"   # Flag to indicate we're running in Spaces
+
+# Import UI module
+try:
+    from app.ui.app import main as ui_main
+    logger.info("Successfully imported UI module")
+except ImportError as e:
+    logger.error(f"Failed to import UI module: {str(e)}")
+    raise
+
+if __name__ == "__main__":
+    logger.info("Starting AI Creative Studio on Hugging Face Spaces")
+    ui_main()

app/config/execution.json

@@ -0,0 +1,34 @@
+{
+  "input_class" : {
+    "package" : "ontology_dc8f06af066e4a7880a5938933236037.input",
+    "class" : "InputClass"
+  },
+  "input_schema" : {
+    "package" : "ontology_dc8f06af066e4a7880a5938933236037.input",
+    "class" : "InputClassSchema"
+  },
+  "output_class" : {
+    "package" : "ontology_dc8f06af066e4a7880a5938933236037.output",
+    "class" : "OutputClass"
+  },
+  "output_schema" : {
+    "package" : "ontology_dc8f06af066e4a7880a5938933236037.output",
+    "class" : "OutputClassSchema"
+  },
+  "config_class" : {
+    "package" : "ontology_dc8f06af066e4a7880a5938933236037.config",
+    "class" : "ConfigClass"
+  },
+  "config_schema" : {
+    "package" : "ontology_dc8f06af066e4a7880a5938933236037.config",
+    "class" : "ConfigClassSchema"
+  },
+  "main_callback" : {
+    "package" : "main",
+    "function" : "execute"
+  },
+  "config_callback" : {
+    "package" : "main",
+    "function" : "config"
+  }
+}

app/config/manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "ai-test",
+  "version": "1.0",
+  "description": "An application for demonstrating your skills in AI",
+  "organization": "",
+  "sdk": "0.2.9",
+  "overview": "",
+  "input": "dc8f06af066e4a7880a5938933236037/b6acb533a2128948785b689c87119355/1.0",
+  "output": "dc8f06af066e4a7880a5938933236037/154ac0a492d67f103915099d81a49f03/1.0",
+  "config": "dc8f06af066e4a7880a5938933236037/b0fe7844500e8e21c39605e13d5e64e4/1.0"
+}

app/config/properties.json

@@ -0,0 +1,6 @@
+[
+  {
+    "key": "key",
+    "value": "value"
+  }
+]

app/config/state.json

@@ -0,0 +1,8 @@
+{
+  "super-user": {
+    "app_ids": [
+      "c25dcd829d134ea98f5ae4dd311d13bc.node3.openfabric.network",
+      "f0b5f319156c4819b9827000b17e511a.node3.openfabric.network"
+    ]
+  }
+}

app/core/image_to_3d.py

@@ -0,0 +1,522 @@
+import os
+import logging
+import base64
+from typing import Dict, Optional, Any, Tuple
+import json
+from pathlib import Path
+import time
+import uuid
+import random
+import requests
+from dotenv import load_dotenv
+
+from .stub import Stub
+
+load_dotenv()
+
+
+logger = logging.getLogger(__name__)
+
+
+class ImageTo3DGenerator:
+    """
+    Handles the image-to-3D generation using Openfabric's API.
+    """
+
+    def __init__(self, stub: Stub, app_id: str = None):
+        """
+        Initialize the image-to-3D generator.
+
+        Args:
+            stub: Stub instance for communicating with Openfabric
+            app_id: The app ID for the image-to-3D service (default: from env var)
+        """
+        self.stub = stub
+        self.app_id = app_id or os.environ.get("IMAGE_TO_3D_APP_ID")
+
+        # Maximum time to wait for job completion (in seconds)
+        self.max_wait_time = 300  # 5 minutes
+
+        # Polling interval for checking job status (in seconds)
+        self.polling_interval = 5  # Check every 5 seconds
+
+        # Use default output directory if MODEL_OUTPUT_DIR is not set
+        model_output_dir = os.environ.get("MODEL_OUTPUT_DIR")
+        if model_output_dir is None:
+            # Default to app/data/models
+            self.output_dir = Path(__file__).parent.parent / "data" / "models"
+            logger.warning(
+                f"MODEL_OUTPUT_DIR not set, using default: {self.output_dir}"
+            )
+        else:
+            self.output_dir = Path(model_output_dir)
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Cache the schema and manifest - don't raise exceptions to allow fallback mode
+        try:
+            self.input_schema = self.stub.schema(self.app_id, "input")
+            self.output_schema = self.stub.schema(self.app_id, "output")
+            self.manifest = self.stub.manifest(self.app_id)
+            logger.info(
+                f"Successfully loaded schema and manifest for image-to-3D app: {self.app_id}"
+            )
+        except Exception as e:
+            logger.warning(f"Failed to load schema/manifest for image-to-3D app: {e}")
+
+    def generate(
+        self, image_path: str, params: Optional[Dict[str, Any]] = None
+    ) -> Tuple[str, str]:
+        """
+        Generate a 3D model from an image.
+
+        Args:
+            image_path: Path to the source image file
+            params: Additional parameters for 3D generation
+
+        Returns:
+            Tuple of (model_path, metadata_path)
+        """
+        # Read the image and convert to base64
+        try:
+            with open(image_path, "rb") as img_file:
+                image_data = base64.b64encode(img_file.read()).decode("utf-8")
+        except Exception as e:
+            logger.error(f"Failed to read image at {image_path}: {e}")
+            raise
+
+        # Prepare the request based on the input schema
+        request_data = self._prepare_request(image_data, params)
+
+        # Log the request
+        logger.info(f"Sending image-to-3D request for image: {image_path}")
+
+        # Send the request to Openfabric
+        rid = None
+        try:
+            start_time = time.time()
+
+            # Make the API call - this will return immediately with a request ID
+            response = self.stub.call(self.app_id, request_data)
+
+            # Extract the request ID from logs
+            rid = self._extract_rid_from_logs()
+            if not rid:
+                raise ValueError("Failed to extract request ID from logs")
+
+            logger.info(f"Submitted image-to-3D job with request ID: {rid}")
+
+            # Poll for job completion
+            qid, result = self._poll_for_completion(rid)
+
+            generation_time = time.time() - start_time
+            logger.info(f"Image-to-3D generation completed in {generation_time:.2f}s")
+
+            if not result:
+                raise ValueError("Failed to get result data after job completion")
+
+            # Process and save the result
+            return self._process_result(result, image_path)
+
+        except Exception as e:
+            logger.error(f"Failed to generate 3D model: {e}")
+            raise
+
+    def _extract_rid_from_logs(self) -> str:
+        """
+        Extract the request ID (rid) from logs.
+        The stub logs the rid when it creates a request in the format "Created rid{rid}"
+
+        Returns:
+            Request ID string or None if not found
+        """
+        import re
+
+        # Try to scan the last few log lines for the request ID pattern
+        log_handler = next(
+            (
+                h
+                for h in logging.getLogger("root").handlers
+                if isinstance(h, logging.StreamHandler)
+            ),
+            None,
+        )
+
+        if hasattr(log_handler, "stream") and hasattr(log_handler.stream, "getvalue"):
+            # This is for StringIO in testing environments
+            log_content = log_handler.stream.getvalue()
+            matches = re.findall(r"Created rid([a-f0-9]+)", log_content)
+            if matches:
+                return matches[-1]  # Return the most recent match
+
+        # Alternative approach: look for the most recently created request
+        try:
+            queue_url = f"https://{self.app_id}/queue/list"
+            response = requests.get(queue_url)
+            if response.status_code == 200:
+                job_list = response.json()
+                if job_list and isinstance(job_list, list) and len(job_list) > 0:
+                    # Sort by creation time (newest first) and get the first one
+                    sorted_jobs = sorted(
+                        job_list, key=lambda x: x.get("created_at", ""), reverse=True
+                    )
+                    return sorted_jobs[0].get("rid")
+        except Exception as e:
+            logger.warning(f"Failed to get request ID from queue: {e}")
+
+        return None
+
+    def _poll_for_completion(self, rid: str) -> Tuple[str, Dict[str, Any]]:
+        """
+        Poll the queue list endpoint until the job is complete.
+
+        Args:
+            rid: Request ID to check
+
+        Returns:
+            Tuple of (queue_id, result_data)
+        """
+        start_time = time.time()
+        qid = None
+        result = None
+
+        logger.info(f"Waiting for job completion (rid: {rid})...")
+
+        while (time.time() - start_time) < self.max_wait_time:
+            try:
+                # Get the queue list
+                queue_url = f"https://{self.app_id}/queue/list"
+                response = requests.get(queue_url)
+
+                if response.status_code != 200:
+                    logger.error(f"Failed to get queue list: {response.status_code}")
+                    time.sleep(self.polling_interval)
+                    continue
+
+                # Parse the response and find our job
+                job_list = response.json()
+                if not isinstance(job_list, list):
+                    logger.error(f"Unexpected queue list format: {type(job_list)}")
+                    time.sleep(self.polling_interval)
+                    continue
+
+                # Find our job by request ID
+                our_job = next((job for job in job_list if job.get("rid") == rid), None)
+
+                if not our_job:
+                    logger.warning(f"Job with rid {rid} not found in queue")
+                    time.sleep(self.polling_interval)
+                    continue
+
+                # Get queue ID if we don't have it yet
+                if not qid:
+                    qid = our_job.get("qid")
+                    logger.info(f"Found job with qid: {qid}")
+
+                # Check if job is finished
+                if our_job.get("finished") and our_job.get("status") == "COMPLETED":
+                    logger.info(f"Job completed successfully")
+
+                    # Get the detailed result
+                    result_url = f"https://{self.app_id}/queue/get?qid={qid}"
+                    result_response = requests.get(result_url)
+
+                    if result_response.status_code == 200:
+                        result = result_response.json()
+                        logger.info(f"Got result data: {result}")
+                        return qid, result
+                    else:
+                        logger.error(
+                            f"Failed to get result data: {result_response.status_code}"
+                        )
+
+                elif our_job.get("finished") and our_job.get("status") != "COMPLETED":
+                    # Job failed
+                    status = our_job.get("status")
+                    messages = our_job.get("messages", [])
+                    error_msgs = [
+                        m.get("content") for m in messages if m.get("type") == "ERROR"
+                    ]
+
+                    error_msg = f"Job failed with status: {status}"
+                    if error_msgs:
+                        error_msg += f", errors: {'; '.join(error_msgs)}"
+
+                    logger.error(error_msg)
+                    raise ValueError(error_msg)
+
+                # Job is still running
+                status = our_job.get("status")
+                progress = (
+                    our_job.get("bars", {}).get("default", {}).get("percent", "0")
+                )
+                logger.info(f"Job status: {status}, progress: {progress}%")
+
+            except Exception as e:
+                logger.error(f"Error polling for job completion: {e}")
+
+            # Wait before checking again
+            time.sleep(self.polling_interval)
+
+        # If we get here, we timed out
+        raise TimeoutError(
+            f"Timed out waiting for job completion after {self.max_wait_time} seconds"
+        )
+
+    def _prepare_request(
+        self, image_data: str, params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Prepare the request payload based on the app's input schema.
+
+        Args:
+            image_data: Base64-encoded image data
+            params: Additional parameters for 3D generation
+
+        Returns:
+            Dict containing the properly formatted request payload
+        """
+        # Default parameters for image-to-3D transformation
+        default_params = {
+            "model_type": "textured",  # Options might include: textured, mesh, point_cloud
+            "quality": "standard",  # Options might include: draft, standard, high
+            "format": "glb",  # Output format: glb, obj, etc.
+        }
+
+        # Override defaults with provided params
+        request_params = {**default_params, **(params or {})}
+
+        # Create request based on the actual input schema
+        # The schema specifies 'input_image' as the required field, not 'image'
+        request = {"input_image": image_data, **request_params}
+
+        return request
+
+    def _process_result(
+        self, result: Dict[str, Any], image_path: str
+    ) -> Tuple[str, str]:
+        """
+        Process the result from the image-to-3D app.
+
+        Args:
+            result: The API response
+            image_path: Path to the source image
+
+        Returns:
+            Tuple of (model_path, metadata_path)
+        """
+        # If result is None, raise an error - don't use mock data
+        if result is None:
+            raise ValueError("No result received from image-to-3D generation service")
+
+        try:
+            model_format = "glb"  # Default format for 3D models
+            has_video_preview = False
+            video_data = None
+            model_base64 = None
+
+            # Process Openfabric blob response format (most common case)
+            # This will have 'generated_object' as a data_blob ID (without the base64 data)
+            if "generated_object" in result:
+                # Extract the model data or model blob reference
+                model_data = result.get("generated_object")
+
+                # Check if this is a blob reference (data URI format or plain string)
+                if isinstance(model_data, str):
+                    if "/" in model_data or model_data.startswith("data_"):
+                        # This is a blob ID reference
+                        blob_id = model_data
+                        logger.info(f"3D model generation result ID: {blob_id}")
+
+                        # Prepare the blob URL and try to download the actual model data
+                        try:
+                            # Construct URL for the blob
+                            resource_url = (
+                                f"https://{self.app_id}/resource?reid={blob_id}"
+                            )
+                            logger.info(
+                                f"Fetching 3D model from blob URL: {resource_url}"
+                            )
+
+                            response = requests.get(resource_url)
+
+                            if response.status_code == 200:
+                                # We have the actual model data
+                                model_binary = response.content
+                                model_base64 = base64.b64encode(model_binary).decode(
+                                    "utf-8"
+                                )
+                                logger.info(
+                                    f"Successfully fetched 3D model from blob store"
+                                )
+
+                                # Set format based on content-type if available
+                                content_type = response.headers.get("Content-Type", "")
+                                if "gltf-binary" in content_type:
+                                    model_format = "glb"
+                                elif (
+                                    "gltf+json" in content_type
+                                    or "json" in content_type
+                                ):
+                                    model_format = "gltf"
+                            else:
+                                logger.error(
+                                    f"Failed to fetch blob: {response.status_code} - {response.text}"
+                                )
+                                raise ValueError(
+                                    f"Failed to fetch blob data: {response.status_code}"
+                                )
+                        except Exception as blob_error:
+                            logger.error(f"Error accessing blob store: {blob_error}")
+                            raise ValueError(
+                                f"Failed to fetch 3D model from blob store: {blob_error}"
+                            )
+                    elif "," in model_data and "base64" in model_data:
+                        # Extract base64 data if in data URI format
+                        model_base64 = model_data.split(",", 1)[1]
+                    else:
+                        # Use as-is for plain base64 data
+                        model_base64 = model_data
+                else:
+                    # If model_data is not a string, this is an unexpected format
+                    raise ValueError(
+                        f"Unexpected generated_object type: {type(model_data)}"
+                    )
+
+                # Also handle video preview if available
+                video_data = result.get("video_object")
+                has_video_preview = video_data is not None and video_data != ""
+
+            # Handle result blob reference format (alternative format)
+            elif "result" in result:
+                blob_id = result.get("result")
+                logger.info(f"3D model generation result ID: {blob_id}")
+
+                # Try to fetch the actual model data from the blob store
+                try:
+                    # Construct URL for the blob
+                    resource_url = f"https://{self.app_id}/resource?reid={blob_id}"
+                    logger.info(f"Fetching 3D model from blob URL: {resource_url}")
+
+                    response = requests.get(resource_url)
+
+                    if response.status_code == 200:
+                        # We have the actual model data
+                        model_binary = response.content
+                        model_base64 = base64.b64encode(model_binary).decode("utf-8")
+                        logger.info(f"Successfully fetched 3D model from blob store")
+
+                        # Set format based on content-type if available
+                        content_type = response.headers.get("Content-Type", "")
+                        if "gltf-binary" in content_type:
+                            model_format = "glb"
+                        elif "gltf+json" in content_type or "json" in content_type:
+                            model_format = "gltf"
+                    else:
+                        logger.error(
+                            f"Failed to fetch blob: {response.status_code} - {response.text}"
+                        )
+                        raise ValueError(
+                            f"Failed to fetch blob data: {response.status_code}"
+                        )
+                except Exception as blob_error:
+                    logger.error(f"Error accessing blob store: {blob_error}")
+                    raise ValueError(
+                        f"Failed to fetch 3D model from blob store: {blob_error}"
+                    )
+
+            # Handle direct model data format (which has 'model' field)
+            elif "model" in result:
+                model_data = result.get("model")
+                model_format = result.get("format", "glb")
+
+                if isinstance(model_data, str):
+                    if "," in model_data:
+                        # Extract base64 data if in data URI format
+                        model_base64 = model_data.split(",", 1)[1]
+                    else:
+                        model_base64 = model_data
+                else:
+                    # Use as-is for binary data
+                    model_base64 = model_data
+                has_video_preview = False
+            else:
+                raise KeyError(
+                    f"Could not identify response format. Keys: {list(result.keys())}"
+                )
+
+            if not model_base64:
+                raise ValueError("No model data found in the result")
+
+            # Generate a unique ID for this model and timestamp
+            model_id = str(uuid.uuid4())
+            timestamp = int(time.time())
+
+            # NEW: Extract the base filename from the source image to use for the model
+            source_image_filename = Path(image_path).name
+            base_name = source_image_filename.rsplit(".", 1)[0]  # Remove extension
+
+            # If base name doesn't already include timestamp, add it
+            if not any(c.isdigit() for c in base_name):
+                base_name = f"{base_name}_{timestamp}"
+
+            # Append "_3d" to clearly indicate this is a 3D model derived from the image
+            base_name = f"{base_name}_3d"
+
+            # Create filenames based on the image name pattern
+            model_filename = f"{base_name}.{model_format}"
+            metadata_filename = f"{base_name}.json"
+
+            # Create paths for model and metadata
+            model_path = self.output_dir / model_filename
+            metadata_path = self.output_dir / metadata_filename
+
+            # Create path for video preview if available
+            video_path = None
+            if has_video_preview and video_data:
+                video_filename = f"{base_name}_preview.mp4"
+                video_path = self.output_dir / video_filename
+                try:
+                    # Extract video base64 data
+                    video_base64 = video_data
+                    if isinstance(video_data, str) and "," in video_data:
+                        video_base64 = video_data.split(",", 1)[1]
+
+                    # Save the video preview
+                    with open(video_path, "wb") as video_file:
+                        video_file.write(base64.b64decode(video_base64))
+                    logger.info(f"Video preview saved to {video_path}")
+                except Exception as video_error:
+                    logger.error(f"Failed to save video preview: {video_error}")
+                    video_path = None
+
+            # Save the model file
+            with open(model_path, "wb") as model_file:
+                model_file.write(base64.b64decode(model_base64))
+
+            # Save metadata linking image to 3D model
+            metadata = {
+                "id": model_id,
+                "timestamp": timestamp,
+                "source_image": image_path,
+                "source_image_filename": source_image_filename,
+                "file_path": str(model_path),
+                "format": model_format,
+                "type": "3d_model",
+                "has_video_preview": has_video_preview,
+                "video_path": str(video_path) if video_path else None,
+                "result_id": result.get("result", result.get("generated_object", "")),
+                "parameters": result.get("parameters", {}),
+            }
+
+            with open(metadata_path, "w") as meta_file:
+                json.dump(metadata, meta_file)
+
+            logger.info(f"3D model saved to {model_path}")
+            logger.info(f"Metadata saved to {metadata_path}")
+
+            return str(model_path), str(metadata_path)
+
+        except Exception as e:
+            logger.error(f"Failed to process 3D model result: {e}")
+            raise

app/core/pipeline.py

@@ -0,0 +1,344 @@
+import logging
+import os
+import sys
+import json
+import requests
+from typing import Dict, Any, Optional, Tuple
+from pathlib import Path
+import importlib
+import importlib.util
+
+# Use relative imports for modules in the same package
+from .text_to_image import TextToImageGenerator
+from .image_to_3d import ImageTo3DGenerator
+from .stub import Stub
+
+# Remove the sys.path.append since we'll use relative imports instead
+sys.path.append(
+    str(Path(__file__).parent.parent)
+)  # Add parent directory to path for imports
+from llm.client import LLMClient
+
+logger = logging.getLogger(__name__)
+
+
+class PipelineResult:
+    """Data class to store the results of a creation pipeline run"""
+
+    def __init__(
+        self,
+        success: bool = False,
+        original_prompt: str = None,
+        expanded_prompt: str = None,
+        image_path: str = None,
+        image_metadata_path: str = None,
+        model_path: str = None,
+        model_metadata_path: str = None,
+    ):
+        self.success = success
+        self.original_prompt = original_prompt
+        self.expanded_prompt = expanded_prompt
+        self.image_path = image_path
+        self.image_metadata_path = image_metadata_path
+        self.model_path = model_path
+        self.model_metadata_path = model_metadata_path
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary representation"""
+        return {
+            "success": self.success,
+            "original_prompt": self.original_prompt,
+            "expanded_prompt": self.expanded_prompt,
+            "image_path": self.image_path,
+            "image_metadata_path": self.image_metadata_path,
+            "model_path": self.model_path,
+            "model_metadata_path": self.model_metadata_path,
+        }
+
+
+class CreativePipeline:
+    """
+    Orchestrates the end-to-end creative pipeline from prompt to 3D model.
+
+    Flow:
+    1. Take user prompt
+    2. Enhance with local LLM
+    3. Generate image from enhanced prompt
+    4. Create 3D model from image
+    5. Return comprehensive results
+    """
+
+    def __init__(self, stub: Stub):
+        """
+        Initialize the creative pipeline components.
+
+        Args:
+            stub: Stub instance for communicating with Openfabric apps
+        """
+        self.stub = stub
+
+        # Initialize LLM client
+        llm_service_url = os.environ.get("LLM_SERVICE_URL")
+        self.llm_client = LLMClient(base_url=llm_service_url)
+
+        # Initialize generators
+        self.text_to_image = TextToImageGenerator(stub)
+        self.image_to_3d = ImageTo3DGenerator(stub)
+
+        # Ensure app/data directories exist
+        data_dir = Path(__file__).parent.parent / "data"
+        data_dir.mkdir(exist_ok=True)
+        (data_dir / "images").mkdir(exist_ok=True)
+        (data_dir / "models").mkdir(exist_ok=True)
+        (data_dir / "downloads").mkdir(exist_ok=True)
+
+        logger.info("Creative pipeline initialized successfully")
+
+    def create(self, prompt: str, params: Dict[str, Any] = None) -> PipelineResult:
+        """
+        Run the creative pipeline from text prompt to 3D model.
+
+        Args:
+            prompt: The user's text prompt
+            params: Optional parameters for the pipeline stages
+
+        Returns:
+            PipelineResult object with paths to generated assets
+        """
+        try:
+            # 1. Enhance the prompt with the LLM
+            logger.info(f"Enhancing prompt: '{prompt}'")
+            try:
+                expanded_prompt = self.llm_client.expand_prompt(prompt)
+                logger.info(f"Enhanced prompt: '{expanded_prompt}'")
+            except Exception as e:
+                logger.warning(f"Failed to enhance prompt: {e}")
+                # Fall back to original prompt if enhancement fails
+                expanded_prompt = prompt
+                logger.info(f"Using original prompt: '{expanded_prompt}'")
+
+            # 2. Generate image from the enhanced prompt
+            image_params = params.get("image", {}) if params else {}
+            image_path, image_metadata_path = self.text_to_image.generate(
+                expanded_prompt, image_params, original_prompt=prompt
+            )
+
+            # If image_path is None but we have metadata, we need to download from blob store
+            if image_path is None and image_metadata_path:
+                try:
+                    # Import the blob viewer downloader directly
+                    tools_dir = str(Path(__file__).parent.parent / "tools")
+                    sys.path.append(tools_dir)
+
+                    try:
+                        # Try direct import first
+                        from tools.blob_viewer import (
+                            download_resource,
+                            construct_resource_url,
+                        )
+                    except ImportError:
+                        # If that fails, use importlib with proper error handling
+                        blob_viewer_path = os.path.join(tools_dir, "blob_viewer.py")
+                        spec = importlib.util.spec_from_file_location(
+                            "blob_viewer", blob_viewer_path
+                        )
+                        blob_viewer = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(blob_viewer)
+                        download_resource = blob_viewer.download_resource
+                        construct_resource_url = blob_viewer.construct_resource_url
+
+                    # Read metadata to get blob ID and other info
+                    with open(image_metadata_path, "r") as f:
+                        metadata = json.load(f)
+
+                    if "result_id" in metadata and metadata["result_id"] != "mock":
+                        blob_id = metadata["result_id"]
+                        logger.info(f"Downloading image from blob store: {blob_id}")
+
+                        # Parse the blob ID
+                        parts = blob_id.split("/")
+                        data_blob_id = parts[0]
+                        execution_id = parts[2] if len(parts) > 2 else None
+
+                        # Target directory
+                        images_dir = Path(__file__).parent.parent / "data" / "images"
+
+                        # Get the existing metadata filename and use it for the image
+                        metadata_filename = Path(image_metadata_path).name
+                        base_filename = metadata_filename.rsplit(".", 1)[0]
+                        image_filename = f"{base_filename}.png"
+
+                        # Prepare full paths
+                        target_image_path = images_dir / image_filename
+
+                        # Update the metadata file with additional information
+                        metadata.update(
+                            {
+                                "original_prompt": prompt,
+                                "expanded_prompt": expanded_prompt,
+                                "needs_download": False,  # Mark as downloaded
+                            }
+                        )
+
+                        # Write the updated metadata back to the file
+                        with open(image_metadata_path, "w") as f:
+                            json.dump(metadata, f, indent=2)
+
+                        # Call the download function with our custom path
+                        url = construct_resource_url(data_blob_id, execution_id)
+                        response = requests.get(url)
+
+                        if response.status_code == 200:
+                            with open(target_image_path, "wb") as f:
+                                f.write(response.content)
+                            image_path = str(target_image_path)
+                            logger.info(f"Generated image at {image_path}")
+                        else:
+                            logger.error(
+                                f"Failed to download image: {response.status_code}"
+                            )
+                            return PipelineResult(
+                                success=False,
+                                original_prompt=prompt,
+                                expanded_prompt=expanded_prompt,
+                            )
+                except Exception as e:
+                    logger.error(f"Failed to download image from blob store: {e}")
+                    return PipelineResult(
+                        success=False,
+                        original_prompt=prompt,
+                        expanded_prompt=expanded_prompt,
+                    )
+
+            # Return early if we couldn't generate an image
+            if not image_path:
+                logger.error("Failed to generate image")
+                return PipelineResult(
+                    success=False,
+                    original_prompt=prompt,
+                    expanded_prompt=expanded_prompt,
+                )
+
+            logger.info(f"Generated image at {image_path}")
+
+            # 3. Generate 3D model from the image
+            model_params = params.get("model", {}) if params else {}
+            try:
+                logger.info(f"Starting 3D model generation from image: {image_path}")
+                # The generate method will now handle all the asynchronous processing internally
+                model_path, model_metadata_path = self.image_to_3d.generate(
+                    image_path, model_params
+                )
+
+                # Verify the model was generated successfully
+                if not Path(model_path).exists():
+                    raise FileNotFoundError(
+                        f"Generated model file not found at {model_path}"
+                    )
+
+                logger.info(f"Successfully generated 3D model at {model_path}")
+                logger.info(f"Model metadata saved at {model_metadata_path}")
+
+                # Load metadata to include additional details in the response
+                try:
+                    with open(model_metadata_path, "r") as f:
+                        model_metadata = json.load(f)
+                    logger.info(
+                        f"3D model format: {model_metadata.get('format', 'unknown')}"
+                    )
+
+                    # Check for video preview
+                    if model_metadata.get("has_video_preview") and model_metadata.get(
+                        "video_path"
+                    ):
+                        logger.info(
+                            f"3D model includes video preview at {model_metadata.get('video_path')}"
+                        )
+                except Exception as metadata_err:
+                    logger.warning(f"Could not read model metadata: {metadata_err}")
+
+                # Successful full pipeline
+                return PipelineResult(
+                    success=True,
+                    original_prompt=prompt,
+                    expanded_prompt=expanded_prompt,
+                    image_path=image_path,
+                    image_metadata_path=image_metadata_path,
+                    model_path=model_path,
+                    model_metadata_path=model_metadata_path,
+                )
+            except Exception as e:
+                logger.error(f"Failed to generate 3D model: {e}")
+                # Partial pipeline success (image only)
+                return PipelineResult(
+                    success=False,
+                    original_prompt=prompt,
+                    expanded_prompt=expanded_prompt,
+                    image_path=image_path,
+                    image_metadata_path=image_metadata_path,
+                )
+
+        except Exception as e:
+            logger.error(f"Pipeline error: {e}")
+            return PipelineResult(success=False, original_prompt=prompt)
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Check health status of all components.
+
+        Returns:
+            Dictionary with health status of each component
+        """
+        health = {
+            "pipeline": "initializing",
+            "llm": "unknown",
+            "text_to_image": "unknown",
+            "image_to_3d": "unknown",
+        }
+
+        # Check LLM service
+        try:
+            llm_health = self.llm_client.health_check()
+            health["llm"] = (
+                "healthy" if llm_health.get("status") == "healthy" else "unhealthy"
+            )
+        except Exception:
+            health["llm"] = "unavailable"
+
+        # Check text-to-image service
+        try:
+            # Check if the service has a connection
+            if (
+                hasattr(self.text_to_image, "stub")
+                and hasattr(self.text_to_image.stub, "_connections")
+                and self.text_to_image.app_id in self.text_to_image.stub._connections
+            ):
+                health["text_to_image"] = "healthy"
+            else:
+                health["text_to_image"] = "degraded"
+        except Exception:
+            health["text_to_image"] = "unavailable"
+
+        # Check image-to-3D service
+        try:
+            # Check if the service has a connection
+            if (
+                hasattr(self.image_to_3d, "stub")
+                and hasattr(self.image_to_3d.stub, "_connections")
+                and self.image_to_3d.app_id in self.image_to_3d.stub._connections
+            ):
+                health["image_to_3d"] = "healthy"
+            else:
+                health["image_to_3d"] = "degraded"
+        except Exception:
+            health["image_to_3d"] = "unavailable"
+
+        # Overall health
+        if all(v == "healthy" for v in health.values()):
+            health["pipeline"] = "healthy"
+        elif "unavailable" in health.values():
+            health["pipeline"] = "degraded"
+        else:
+            health["pipeline"] = "partially available"
+
+        return health

app/core/remote.py

@@ -0,0 +1,106 @@
+from typing import Optional, Union
+
+from openfabric_pysdk.helper import Proxy
+from openfabric_pysdk.helper.proxy import ExecutionResult
+
+
+class Remote:
+    """
+    Remote is a helper class that interfaces with an Openfabric Proxy instance
+    to send input data, execute computations, and fetch results synchronously
+    or asynchronously.
+
+    Attributes:
+        proxy_url (str): The URL to the proxy service.
+        proxy_tag (Optional[str]): An optional tag to identify a specific proxy instance.
+        client (Optional[Proxy]): The initialized proxy client instance.
+    """
+
+    # ----------------------------------------------------------------------
+    def __init__(self, proxy_url: str, proxy_tag: Optional[str] = None):
+        """
+        Initializes the Remote instance with the proxy URL and optional tag.
+
+        Args:
+            proxy_url (str): The base URL of the proxy.
+            proxy_tag (Optional[str]): An optional tag for the proxy instance.
+        """
+        self.proxy_url = proxy_url
+        self.proxy_tag = proxy_tag
+        self.client: Optional[Proxy] = None
+
+    # ----------------------------------------------------------------------
+    def connect(self) -> "Remote":
+        """
+        Establishes a connection with the proxy by instantiating the Proxy client.
+
+        Returns:
+            Remote: The current instance for chaining.
+        """
+        # self.client = Proxy(self.proxy_url, self.proxy_tag, ssl_verify=False)
+
+        # Remove ssl_verify parameter since it's not supported by the Proxy class
+        self.client = Proxy(self.proxy_url, self.proxy_tag)
+        return self
+
+    # ----------------------------------------------------------------------
+    def execute(self, inputs: dict, uid: str) -> Union[ExecutionResult, None]:
+        """
+        Executes an asynchronous request using the proxy client.
+
+        Args:
+            inputs (dict): The input payload to send to the proxy.
+            uid (str): A unique identifier for the request.
+
+        Returns:
+            Union[ExecutionResult, None]: The result of the execution, or None if not connected.
+        """
+        if self.client is None:
+            return None
+
+        return self.client.request(inputs, uid)
+
+    # ----------------------------------------------------------------------
+    @staticmethod
+    def get_response(output: ExecutionResult) -> Union[dict, None]:
+        """
+        Waits for the result and processes the output.
+
+        Args:
+            output (ExecutionResult): The result returned from a proxy request.
+
+        Returns:
+            Union[dict, None]: The response data if successful, None otherwise.
+
+        Raises:
+            Exception: If the request failed or was cancelled.
+        """
+        if output is None:
+            return None
+
+        output.wait()
+        status = str(output.status()).lower()
+        if status == "completed":
+            return output.data()
+        if status in ("cancelled", "failed"):
+            raise Exception("The request to the proxy app failed or was cancelled!")
+        return None
+
+    # ----------------------------------------------------------------------
+    def execute_sync(self, inputs: dict, configs: dict, uid: str) -> Union[dict, None]:
+        """
+        Executes a synchronous request with configuration parameters.
+
+        Args:
+            inputs (dict): The input payload.
+            configs (dict): Additional configuration parameters.
+            uid (str): A unique identifier for the request.
+
+        Returns:
+            Union[dict, None]: The processed response, or None if not connected.
+        """
+        if self.client is None:
+            return None
+
+        output = self.client.execute(inputs, configs, uid)
+        return Remote.get_response(output)

app/core/stub.py

@@ -0,0 +1,137 @@
+import logging
+from typing import Any, Dict, List, Literal, Tuple
+
+import requests
+
+from .remote import Remote
+
+# Type aliases for clarity
+Manifests = Dict[str, dict]
+Schemas = Dict[str, Tuple[dict, dict]]
+Connections = Dict[str, Remote]
+
+
+class Stub:
+    """
+    Stub acts as a lightweight client interface that initializes remote connections
+    to multiple Openfabric applications, fetching their manifests, schemas, and enabling
+    execution of calls to these apps.
+
+    Attributes:
+        _schema (Schemas): Stores input/output schemas for each app ID.
+        _manifest (Manifests): Stores manifest metadata for each app ID.
+        _connections (Connections): Stores active Remote connections for each app ID.
+    """
+
+    # ----------------------------------------------------------------------
+    def __init__(self, app_ids: List[str]):
+        """
+        Initializes the Stub instance by loading manifests, schemas, and connections
+        for each given app ID.
+
+        Args:
+            app_ids (List[str]): A list of application identifiers (hostnames or URLs).
+        """
+        self._schema: Schemas = {}
+        self._manifest: Manifests = {}
+        self._connections: Connections = {}
+
+        for app_id in app_ids:
+            base_url = app_id.strip("/")
+
+            try:
+                # Fetch manifest
+                manifest = requests.get(f"https://{base_url}/manifest").json()
+                logging.info(f"[{app_id}] Manifest loaded.")
+                self._manifest[app_id] = manifest
+
+                # Fetch input schema
+                input_schema = requests.get(
+                    f"https://{base_url}/schema?type=input"
+                ).json()
+                logging.info(f"[{app_id}] Input schema loaded.")
+
+                # Fetch output schema
+                output_schema = requests.get(
+                    f"https://{base_url}/schema?type=output"
+                ).json()
+                logging.info(f"[{app_id}] Output schema loaded.")
+                self._schema[app_id] = (input_schema, output_schema)
+
+                # Establish Remote WebSocket connection
+                self._connections[app_id] = Remote(
+                    f"wss://{base_url}", f"{app_id}-proxy"
+                ).connect()
+                logging.info(f"[{app_id}] Connection established.")
+            except Exception as e:
+                logging.error(f"[{app_id}] Initialization failed: {e}")
+
+    # ----------------------------------------------------------------------
+    def call(self, app_id: str, data: Any, uid: str = "super-user") -> dict:
+        """
+        Sends a request to the specified app via its Remote connection.
+
+        Args:
+            app_id (str): The application ID to route the request to.
+            data (Any): The input data to send to the app.
+            uid (str): The unique user/session identifier for tracking (default: 'super-user').
+
+        Returns:
+            dict: The output data returned by the app.
+
+        Raises:
+            Exception: If no connection is found for the provided app ID, or execution fails.
+        """
+        connection = self._connections.get(app_id)
+        if not connection:
+            raise Exception(f"Connection not found for app ID: {app_id}")
+
+        try:
+            handler = connection.execute(data, uid)
+            result = connection.get_response(handler)
+            logging.info(f"[{app_id}] Output: {result}")
+            return result
+        except Exception as e:
+            logging.error(f"[{app_id}] Execution failed: {e}")
+            raise
+
+    # ----------------------------------------------------------------------
+    def manifest(self, app_id: str) -> dict:
+        """
+        Retrieves the manifest metadata for a specific application.
+
+        Args:
+            app_id (str): The application ID for which to retrieve the manifest.
+
+        Returns:
+            dict: The manifest data for the app, or an empty dictionary if not found.
+        """
+        return self._manifest.get(app_id, {})
+
+    # ----------------------------------------------------------------------
+    def schema(self, app_id: str, type: Literal["input", "output"]) -> dict:
+        """
+        Retrieves the input or output schema for a specific application.
+
+        Args:
+            app_id (str): The application ID for which to retrieve the schema.
+            type (Literal['input', 'output']): The type of schema to retrieve.
+
+        Returns:
+            dict: The requested schema (input or output).
+
+        Raises:
+            ValueError: If the schema type is invalid or the schema is not found.
+        """
+        _input, _output = self._schema.get(app_id, (None, None))
+
+        if type == "input":
+            if _input is None:
+                raise ValueError(f"Input schema not found for app ID: {app_id}")
+            return _input
+        elif type == "output":
+            if _output is None:
+                raise ValueError(f"Output schema not found for app ID: {app_id}")
+            return _output
+        else:
+            raise ValueError("Type must be either 'input' or 'output'")

app/core/text_to_image.py

@@ -0,0 +1,259 @@
+import os
+import logging
+import base64
+from typing import Dict, Optional, Any, Tuple
+import json
+from pathlib import Path
+import time
+import uuid
+import random
+from dotenv import load_dotenv
+
+from .stub import Stub
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+
+class TextToImageGenerator:
+    """
+    Handles the text-to-image generation using Openfabric's API.
+    """
+
+    def __init__(self, stub: Stub, app_id: str = None):
+        """
+        Initialize the text-to-image generator.
+
+        Args:
+            stub: Stub instance for communicating with Openfabric
+            app_id: The app ID for the text-to-image service (default: from env var)
+        """
+        self.stub = stub
+        self.app_id = app_id or os.environ.get("TEXT_TO_IMAGE_APP_ID")
+
+        # Use default output directory if IMAGE_OUTPUT_DIR is not set
+        image_output_dir = os.environ.get("IMAGE_OUTPUT_DIR")
+        if image_output_dir is None:
+            # Default to app/data/images
+            self.output_dir = Path(__file__).parent.parent / "data" / "images"
+            logger.warning(
+                f"IMAGE_OUTPUT_DIR not set, using default: {self.output_dir}"
+            )
+        else:
+            self.output_dir = Path(image_output_dir)
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Cache the schema and manifest - don't raise exceptions to allow fallback mode
+        try:
+            self.input_schema = self.stub.schema(self.app_id, "input")
+            self.output_schema = self.stub.schema(self.app_id, "output")
+            self.manifest = self.stub.manifest(self.app_id)
+            logger.info(
+                f"Successfully loaded schema and manifest for text-to-image app: {self.app_id}"
+            )
+        except Exception as e:
+            logger.warning(f"Failed to load schema/manifest for text-to-image app: {e}")
+
+    def generate(
+        self,
+        prompt: str,
+        params: Optional[Dict[str, Any]] = None,
+        original_prompt: str = None,
+    ) -> Tuple[str, str]:
+        """
+        Generate an image from text prompt.
+
+        Args:
+            prompt: The text prompt (expanded by LLM)
+            params: Additional parameters for image generation
+            original_prompt: The original user prompt (used for naming files)
+
+        Returns:
+            Tuple of (image_path, metadata_path)
+        """
+        # Use original prompt for naming if provided, otherwise use expanded prompt
+        file_naming_prompt = original_prompt if original_prompt else prompt
+
+        # Prepare the request based on the input schema
+        request_data = self._prepare_request(prompt, params)
+
+        # Log the request
+        logger.info(f"Sending text-to-image request with prompt: {prompt[:100]}...")
+
+        # Send the request to Openfabric
+        result = None
+        try:
+            start_time = time.time()
+            result = self.stub.call(self.app_id, request_data)
+            generation_time = time.time() - start_time
+            logger.info(f"Text-to-image generation completed in {generation_time:.2f}s")
+        except Exception as e:
+            logger.error(f"Failed to generate image: {e}")
+            # Generate a mock response to continue testing
+
+            # result = self._generate_mock_response(prompt, request_data)
+            # logger.warning("Using mock image response due to service error")
+
+        # Process and save the result
+        return self._process_result(result, prompt, file_naming_prompt)
+
+    def _generate_mock_response(
+        self, prompt: str, request_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Generate a mock image response when the service is unavailable.
+
+        Args:
+            prompt: The text prompt
+            request_data: The original request data
+
+        Returns:
+            A mock response with a simple image
+        """
+        # Create a 1x1 transparent PNG as mock image
+        mock_image = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+
+        return {
+            "image": mock_image,
+            "parameters": {
+                "prompt": prompt,
+                "width": request_data.get("width", 512),
+                "height": request_data.get("height", 512),
+                "steps": request_data.get("num_inference_steps", 30),
+                "guidance_scale": request_data.get("guidance_scale", 7.5),
+                "seed": request_data.get("seed", random.randint(1000, 9999)),
+            },
+        }
+
+    def _prepare_request(
+        self, prompt: str, params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Prepare the request payload based on the app's input schema.
+        """
+        # Default parameters
+        default_params = {
+            "width": 512,
+            "height": 512,
+            "guidance_scale": 7.5,
+            "num_inference_steps": 30,
+            "seed": -1,  # Random seed
+            "negative_prompt": "blurry, low quality, distorted, deformed",
+        }
+
+        # Override defaults with provided params
+        request_params = {**default_params, **(params or {})}
+
+        # Create request based on schema
+        request = {"prompt": prompt, **request_params}
+
+        return request
+
+    def _process_result(
+        self, result: Dict[str, Any], prompt: str, file_naming_prompt: str
+    ) -> Tuple[str, str]:
+        """
+        Process the result from the text-to-image app.
+
+        Args:
+            result: The API response
+            prompt: The original prompt
+            file_naming_prompt: The prompt used for naming files
+
+        Returns:
+            Tuple of (image_path, metadata_path)
+        """
+        # Extract image data or blob ID
+        try:
+            # Generate a unique ID for this image
+            image_id = str(uuid.uuid4())
+            timestamp = int(time.time())
+
+            # Create a more descriptive base filename from the prompt
+            if file_naming_prompt:
+                # Use first 15 chars of prompt, replacing spaces with underscores
+                base_name = (
+                    file_naming_prompt[:15].strip().replace(" ", "_").replace("/", "_")
+                )
+                # Remove any other non-alphanumeric characters
+                base_name = "".join(c for c in base_name if c.isalnum() or c == "_")
+            else:
+                base_name = f"image_{timestamp}"
+
+            # Create paths for metadata
+            metadata_filename = f"{base_name}_{timestamp}.json"
+            metadata_path = self.output_dir / metadata_filename
+
+            # Handle real Openfabric response format (which has 'result' field)
+            if "result" in result:
+                # Log the result ID for reference
+                blob_id = result.get("result")
+                logger.info(f"Image generation result ID: {blob_id}")
+
+                # Create metadata for the image that includes the blob ID
+                # We won't create actual image file path yet since it will be downloaded
+                metadata = {
+                    "id": image_id,
+                    "timestamp": timestamp,
+                    "prompt": prompt,
+                    "parameters": result.get("parameters", {}),
+                    "result_id": blob_id,
+                    "type": "image",
+                    "needs_download": True,
+                    "base_name": base_name,
+                }
+
+                with open(metadata_path, "w") as meta_file:
+                    json.dump(metadata, meta_file, indent=2)
+
+                logger.info(f"Image metadata saved with result ID: {blob_id}")
+                logger.info(f"Use blob_viewer.py to download the actual image")
+
+                # Return the metadata path but no image path since it needs to be downloaded
+                return None, str(metadata_path)
+
+            # If we have direct image data (which would be rare in real use)
+            elif "image" in result:
+                # This is the fallback case if we somehow receive direct image data
+                image_filename = f"{base_name}_{timestamp}.png"
+                image_path = self.output_dir / image_filename
+
+                image_data = result.get("image")
+                if isinstance(image_data, str) and image_data.startswith("data:image"):
+                    # Extract base64 data after the comma
+                    image_base64 = image_data.split(",", 1)[1]
+                else:
+                    image_base64 = image_data
+
+                # Save the image
+                image_bytes = base64.b64decode(image_base64)
+                with open(image_path, "wb") as img_file:
+                    img_file.write(image_bytes)
+
+                # Save metadata
+                metadata = {
+                    "id": image_id,
+                    "timestamp": timestamp,
+                    "prompt": prompt,
+                    "parameters": result.get("parameters", {}),
+                    "file_path": str(image_path),
+                    "type": "image",
+                    "direct_image": True,
+                }
+
+                with open(metadata_path, "w") as meta_file:
+                    json.dump(metadata, meta_file, indent=2)
+
+                logger.info(f"Direct image data saved to {image_path}")
+                return str(image_path), str(metadata_path)
+
+            else:
+                raise KeyError(
+                    f"Unexpected response format. Response keys: {list(result.keys())}"
+                )
+
+        except Exception as e:
+            logger.error(f"Failed to process image result: {e}")
+            raise

app/llm/client.py

@@ -0,0 +1,105 @@
+import requests
+import logging
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    """
+    Client for interacting with the LLM service.
+    Provides methods to generate text and expand creative prompts.
+    """
+
+    def __init__(self, base_url: str = "http://localhost:8001"):
+        """
+        Initialize the LLM client.
+
+        Args:
+            base_url: Base URL of the LLM service
+        """
+        self.base_url = base_url
+        self.session = requests.Session()
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        max_tokens: int = 512,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+    ) -> str:
+        """
+        Generate text based on a prompt.
+
+        Args:
+            prompt: The user prompt to generate from
+            system_prompt: Optional system prompt to guide the generation
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature (higher = more creative)
+            top_p: Top-p sampling parameter
+
+        Returns:
+            The generated text
+
+        Raises:
+            Exception: If the request fails
+        """
+        payload = {
+            "prompt": prompt,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+        }
+
+        if system_prompt:
+            payload["system_prompt"] = system_prompt
+
+        try:
+            response = self.session.post(f"{self.base_url}/generate", json=payload)
+            response.raise_for_status()
+            return response.json()["text"]
+        except requests.RequestException as e:
+            logger.error(f"Failed to generate text: {str(e)}")
+            raise Exception(f"LLM service error: {str(e)}")
+
+    def expand_prompt(self, prompt: str) -> str:
+        """
+        Expand a creative prompt with rich details.
+
+        Args:
+            prompt: The user's original prompt
+
+        Returns:
+            An expanded, detailed creative prompt
+
+        Raises:
+            Exception: If the request fails
+        """
+        try:
+            response = self.session.post(
+                f"{self.base_url}/expand", json={"prompt": prompt}
+            )
+            response.raise_for_status()
+            return response.json()["text"]
+        except requests.RequestException as e:
+            logger.error(f"Failed to expand prompt: {str(e)}")
+            raise Exception(f"LLM service error: {str(e)}")
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Check if the LLM service is healthy.
+
+        Returns:
+            Health status information
+
+        Raises:
+            Exception: If the health check fails
+        """
+        try:
+            response = self.session.get(f"{self.base_url}/health")
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            logger.error(f"Health check failed: {str(e)}")
+            raise Exception(f"LLM service error: {str(e)}")

app/llm/model.py

@@ -0,0 +1,237 @@
+import os
+from typing import Dict, List, Optional, Union
+import logging
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, AutoConfig
+
+logger = logging.getLogger(__name__)
+
+
+class LocalLLM:
+    """
+    A wrapper for running local LLMs using the Hugging Face Transformers library.
+    Optimized for creative prompt expansion and interpretation.
+    """
+
+    def __init__(
+        self,
+        model_path: str = "meta-llama/Llama-3.2-3B-Instruct",
+        device_map: str = "auto",
+        torch_dtype=None,
+    ):
+        """
+        Initialize the local LLM.
+
+        Args:
+            model_path: Path to model or HuggingFace model ID
+            device_map: Device mapping strategy (default: "auto")
+            torch_dtype: Torch data type (default: bfloat16 if available, otherwise float16)
+        """
+        self.model_path = model_path
+        self.device_map = device_map
+
+        if torch_dtype is None:
+            # Set default dtype based on device
+            if device_map == "mps":
+                # Apple Silicon uses float16
+                self.torch_dtype = torch.float16
+            elif (
+                torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8
+            ):
+                # Modern NVIDIA GPUs use bfloat16
+                self.torch_dtype = torch.bfloat16
+            else:
+                # Default to float16 for other cases
+                self.torch_dtype = torch.float16
+        else:
+            self.torch_dtype = torch_dtype
+
+        logger.info(f"Loading LLM from {model_path}")
+        logger.info(f"Using device: {device_map}, dtype: {self.torch_dtype}")
+
+        try:
+            # Load model and tokenizer directly instead of using pipeline
+            # This gives us more control over the configuration
+
+            # First, load and fix the config
+            config = AutoConfig.from_pretrained(model_path)
+
+            # Fix the rope_scaling issue for Llama models
+            if hasattr(config, "rope_scaling") and isinstance(
+                config.rope_scaling, dict
+            ):
+                # Ensure the type key exists and is set to linear
+                config.rope_scaling["type"] = "linear"
+                logger.info("Fixed rope_scaling configuration with type=linear")
+            elif not hasattr(config, "rope_scaling"):
+                # If no rope_scaling exists, add a basic one
+                config.rope_scaling = {"type": "linear", "factor": 1.0}
+                logger.info("Added default rope_scaling configuration")
+
+            # Load the tokenizer
+            tokenizer = AutoTokenizer.from_pretrained(model_path)
+
+            # Load the model with our fixed config
+            if device_map == "mps":
+                # For Apple Silicon, load to device directly
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_path,
+                    config=config,
+                    torch_dtype=self.torch_dtype,
+                    device_map={"": "mps"},  # Map all modules to MPS device
+                )
+            else:
+                # For other devices, use the device_map parameter
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_path,
+                    config=config,
+                    torch_dtype=self.torch_dtype,
+                    device_map=device_map,
+                )
+
+            # Create the pipeline with our pre-loaded model and tokenizer
+            self.pipe = pipeline(
+                "text-generation", model=model, tokenizer=tokenizer, framework="pt"
+            )
+
+            logger.info("LLM loaded successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to load model: {str(e)}")
+            raise
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        max_tokens: int = 512,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+    ) -> str:
+        """
+        Generate text based on a prompt with the local LLM.
+
+        Args:
+            prompt: The user prompt to generate from
+            system_prompt: Optional system prompt to guide the generation
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature (higher = more creative)
+            top_p: Top-p sampling parameter
+
+        Returns:
+            The generated text
+        """
+        # Format messages for chat-style models
+        messages = []
+
+        # Add system prompt if provided
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+
+        # Add user prompt
+        messages.append({"role": "user", "content": prompt})
+
+        logger.debug(f"Generating with prompt: {prompt[:100]}...")
+
+        try:
+            # Generate response using the pipeline
+            outputs = self.pipe(
+                messages,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                do_sample=True,
+            )
+
+            # Extract the assistant's response
+            response = outputs[0]["generated_text"][-1]["content"]
+            return response
+
+        except Exception as e:
+            logger.error(f"Error during generation: {str(e)}")
+            return ""
+
+    def expand_creative_prompt(self, prompt: str) -> str:
+        """
+        Specifically designed to expand a user prompt into a more detailed,
+        creative description suitable for image generation.
+
+        Args:
+            prompt: The user's original prompt
+
+        Returns:
+            An expanded, detailed creative prompt
+        """
+        system_prompt = """You are a creative assistant specializing in enhancing text prompts for image and 3D model generation.
+When given a simple prompt, expand it with rich, vivid details about:
+- Visual elements and composition
+- Lighting, colors, and atmosphere
+- Style, mood, and artistic influence
+- Textures and materials
+- Perspective and framing
+
+Keep your response focused only on the enhanced visual description without explanations or comments.
+Limit to 3-4 sentences maximum, ensuring it's concise yet richly detailed."""
+
+        # Generate the expanded prompt
+        expanded = self.generate(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            max_tokens=256,
+            temperature=0.8,  # Slightly higher temperature for creativity
+        )
+
+        logger.info(f"Expanded prompt: {expanded[:100]}...")
+        return expanded
+
+
+def get_llm_instance(model_path: Optional[str] = None) -> LocalLLM:
+    """
+    Factory function to get a LocalLLM instance with default settings.
+
+    Args:
+        model_path: Optional path to model or HuggingFace model ID
+
+    Returns:
+        A LocalLLM instance
+    """
+    # If model path not provided, first check for MODEL_PATH, then MODEL_ID from environment
+    if not model_path:
+        model_path = os.environ.get("MODEL_PATH") or os.environ.get(
+            "MODEL_ID", "meta-llama/Llama-3.2-3B-Instruct"
+        )
+
+    # Check if the provided path is a local directory
+    if os.path.isdir(model_path):
+        logger.info(f"Using local model directory: {model_path}")
+    else:
+        logger.info(f"Using model ID from Hugging Face: {model_path}")
+
+    # Check available device backends
+    device_map = "auto"
+    torch_dtype = None
+
+    # Check for Apple Silicon (M1/M2/M3) MPS support
+    if torch.backends.mps.is_available():
+        logger.info(
+            "Apple Silicon MPS is available. Using MPS backend for accelerated inference."
+        )
+        device_map = "mps"
+        torch_dtype = torch.float16
+    # Otherwise check if CUDA is available
+    elif torch.cuda.is_available():
+        logger.info(f"CUDA is available. Using {torch.cuda.get_device_name(0)}")
+        if torch.cuda.get_device_capability()[0] >= 8:
+            # For Ampere architecture (30XX, A100, etc.) use bfloat16
+            torch_dtype = torch.bfloat16
+        else:
+            # For older architectures use float16
+            torch_dtype = torch.float16
+    else:
+        logger.warning(
+            "No GPU acceleration available. Using CPU. This may be slow for inference."
+        )
+
+    return LocalLLM(
+        model_path=model_path, device_map=device_map, torch_dtype=torch_dtype
+    )

app/llm/service.py

@@ -0,0 +1,213 @@
+import os
+import logging
+import time
+import sys
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional
+import psutil
+import uvicorn
+from dotenv import load_dotenv
+from pathlib import Path
+from model import LocalLLM, get_llm_instance
+
+# Configure logging first
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler(os.path.join(os.path.dirname(__file__), "llm_service.log")),
+    ],
+)
+logger = logging.getLogger("llm_service")
+
+# Try to load .env file from project root
+env_path = Path(__file__).parents[2] / ".env"
+if env_path.exists():
+    load_dotenv(dotenv_path=env_path)
+    logger.info(f"Loaded environment variables from {env_path}")
+
+
+# Initialize FastAPI app
+app = FastAPI(title="Local LLM Service", description="API for local LLM interaction")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Request timing middleware
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start_time = time.time()
+    logger.info(f"Request started: {request.method} {request.url.path}")
+
+    response = await call_next(request)
+
+    process_time = time.time() - start_time
+    logger.info(
+        f"Request completed: {request.method} {request.url.path} - Status: {response.status_code} - Duration: {process_time:.4f}s"
+    )
+
+    return response
+
+
+# Model request and response classes
+class PromptRequest(BaseModel):
+    prompt: str
+    system_prompt: Optional[str] = None
+    max_tokens: int = 512
+    temperature: float = 0.7
+    top_p: float = 0.9
+
+
+class ExpandRequest(BaseModel):
+    prompt: str
+
+
+class LLMResponse(BaseModel):
+    text: str
+
+
+# Global LLM instance
+llm = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the LLM on startup"""
+    global llm
+    logger.info("Starting LLM service initialization...")
+
+    # First check for MODEL_PATH (local model), then fall back to MODEL_ID
+    model_path = os.environ.get("MODEL_PATH")
+    if model_path and os.path.isdir(model_path):
+        logger.info(f"Using local model from MODEL_PATH: {model_path}")
+    else:
+        # Fall back to MODEL_ID if MODEL_PATH isn't set or doesn't exist
+        model_path = os.environ.get("MODEL_ID", "meta-llama/Llama-3.2-3B-Instruct")
+        logger.info(f"Using model ID from Hugging Face: {model_path}")
+
+    try:
+        start_time = time.time()
+        llm = get_llm_instance(model_path)
+        init_time = time.time() - start_time
+
+        logger.info(
+            f"LLM initialized successfully with model: {model_path} in {init_time:.2f} seconds"
+        )
+
+        memory = psutil.virtual_memory()
+        logger.info(
+            f"System memory: {memory.percent}% used ({memory.used / (1024**3):.1f}GB / {memory.total / (1024**3):.1f}GB)"
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to initialize LLM: {str(e)}", exc_info=True)
+        raise
+
+
+@app.post("/generate", response_model=LLMResponse)
+async def generate_text(request: PromptRequest):
+    """Generate text based on a prompt"""
+    logger.info(
+        f"Received text generation request, prompt length: {len(request.prompt)} chars"
+    )
+    logger.debug(f"Prompt: {request.prompt[:50]}...")
+
+    if not llm:
+        logger.error("LLM service not initialized when generate endpoint was called")
+        raise HTTPException(status_code=503, detail="LLM service not initialized")
+
+    try:
+        start_time = time.time()
+
+        logger.info(
+            f"Generation parameters: max_tokens={request.max_tokens}, temperature={request.temperature}, top_p={request.top_p}"
+        )
+
+        response = llm.generate(
+            prompt=request.prompt,
+            system_prompt=request.system_prompt,
+            max_tokens=request.max_tokens,
+            temperature=request.temperature,
+            top_p=request.top_p,
+        )
+
+        generation_time = time.time() - start_time
+        response_length = len(response)
+
+        logger.info(
+            f"Text generation completed in {generation_time:.2f}s, response length: {response_length} chars"
+        )
+        logger.debug(f"Generated response: {response[:50]}...")
+
+        return LLMResponse(text=response)
+    except Exception as e:
+        logger.error(f"Error generating text: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/expand", response_model=LLMResponse)
+async def expand_prompt(request: ExpandRequest):
+    """Expand a creative prompt with rich details"""
+    logger.info(f"Received prompt expansion request, prompt: '{request.prompt}'")
+
+    if not llm:
+        logger.error("LLM service not initialized when expand endpoint was called")
+        raise HTTPException(status_code=503, detail="LLM service not initialized")
+
+    try:
+        start_time = time.time()
+
+        expanded = llm.expand_creative_prompt(request.prompt)
+
+        expansion_time = time.time() - start_time
+        expanded_length = len(expanded)
+
+        logger.info(
+            f"Prompt expansion completed in {expansion_time:.2f}s, original length: {len(request.prompt)}, expanded length: {expanded_length}"
+        )
+        logger.debug(f"Original: '{request.prompt}'")
+        logger.debug(f"Expanded: '{expanded}'")
+
+        return LLMResponse(text=expanded)
+    except Exception as e:
+        logger.error(f"Error expanding prompt: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    logger.debug("Health check endpoint called")
+
+    if llm:
+        logger.info(f"Health check: LLM service is healthy, model: {llm.model_path}")
+        return {"status": "healthy", "model": llm.model_path}
+
+    logger.warning("Health check: LLM service is still initializing")
+    return {"status": "initializing"}
+
+
+# Start the service if run directly
+if __name__ == "__main__":
+
+    # Check for psutil dependency
+    try:
+        import psutil
+    except ImportError:
+        logger.warning(
+            "psutil not installed. Some system resource metrics will not be available."
+        )
+        logger.warning("Install with: pip install psutil")
+
+    logger.info("Starting LLM service server")
+    uvicorn.run(app, host="0.0.0.0", port=8001)

app/main.py

@@ -0,0 +1,113 @@
+import logging
+import os
+from typing import Dict
+from pathlib import Path
+from dotenv import load_dotenv
+
+from ontology_dc8f06af066e4a7880a5938933236037.config import ConfigClass
+from ontology_dc8f06af066e4a7880a5938933236037.input import InputClass
+from ontology_dc8f06af066e4a7880a5938933236037.output import OutputClass
+from openfabric_pysdk.context import State
+from core.stub import Stub
+from core.pipeline import CreativePipeline
+
+
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# Configurations for the app
+configurations: Dict[str, ConfigClass] = dict()
+
+
+############################################################
+# Config callback function
+############################################################
+def config(configuration: Dict[str, ConfigClass], state: State) -> None:
+    """
+    Stores user-specific configuration data.
+
+    Args:
+        configuration (Dict[str, ConfigClass]): A mapping of user IDs to configuration objects.
+        state (State): The current state of the application (not used in this implementation).
+    """
+    for uid, conf in configuration.items():
+        logging.info(f"Saving new config for user with id:'{uid}'")
+        configurations[uid] = conf
+
+
+############################################################
+# Execution callback function
+############################################################
+def execute(request_data) -> None:
+    """
+    Main execution entry point for handling a model pass.
+
+    Args:
+        request_data: The object containing request and response structures.
+    """
+
+    # Retrieve input
+    request: InputClass = request_data.request
+    user_prompt = request.prompt
+
+    # Log the incoming request
+    logger.info(f"Received request with prompt: '{user_prompt}'")
+
+    # Retrieve user config
+    user_config: ConfigClass = configurations.get("super-user", None)
+    logger.info(f"Using configuration: {configurations}")
+
+    # Initialize the Stub with app IDs
+    app_ids = user_config.app_ids if user_config else []
+
+    # Make sure app IDs are available
+    if not app_ids:
+        text_to_image_app_id = os.environ.get("TEXT_TO_IMAGE_APP_ID")
+        image_to_3d_app_id = os.environ.get("IMAGE_TO_3D_APP_ID")
+        app_ids = [text_to_image_app_id, image_to_3d_app_id]
+        logger.info(
+            f"No app_ids found in config, using environment defaults: {app_ids}"
+        )
+
+    stub = Stub(app_ids)
+
+    # Create the creative pipeline
+    pipeline = CreativePipeline(stub)
+
+    # Execute the creative pipeline
+    try:
+        logger.info(f"Executing creative pipeline for prompt: '{user_prompt}'")
+        result = pipeline.create(prompt=user_prompt)
+
+        if result.success:
+            response_message = (
+                f"Created successfully! From your prompt '{user_prompt}', "
+                f"I generated an image and a 3D model."
+            )
+            logger.info(f"Pipeline completed successfully: {result.to_dict()}")
+        else:
+            if result.image_path:
+                response_message = (
+                    f"Partially completed. I was able to generate an image from "
+                    f"your prompt '{user_prompt}', but couldn't create the 3D model."
+                )
+                logger.warning(f"Pipeline partially completed: {result.to_dict()}")
+            else:
+                response_message = (
+                    f"I'm sorry, I couldn't process your request '{user_prompt}'. "
+                    f"Please try again with a different description."
+                )
+                logger.error(f"Pipeline failed: {result.to_dict()}")
+    except Exception as e:
+        logger.error(f"Error executing pipeline: {e}")
+        response_message = f"An error occurred while processing your request: {str(e)}"
+
+    # Prepare response
+    response: OutputClass = request_data.response
+    response.message = response_message

app/ontology_dc8f06af066e4a7880a5938933236037/config.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import List
+
+from marshmallow import Schema, fields, post_load
+
+from openfabric_pysdk.utility import SchemaUtil
+
+
+################################################################
+# Config concept class - AUTOGENERATED
+################################################################
+@dataclass
+class ConfigClass:
+    app_ids: List[str] = None
+
+
+################################################################
+# ConfigSchema concept class - AUTOGENERATED
+################################################################
+class ConfigClassSchema(Schema):
+    app_ids = fields.List(fields.String())
+
+    @post_load
+    def create(self, data, **kwargs):
+        return SchemaUtil.create(ConfigClass(), data)

app/ontology_dc8f06af066e4a7880a5938933236037/input.py

@@ -0,0 +1,28 @@
+from decimal import *
+from datetime import *
+from typing import *
+
+from dataclasses import dataclass
+from marshmallow import Schema, fields, post_load
+from openfabric_pysdk.utility import SchemaUtil
+
+
+################################################################
+# Input concept class - AUTOGENERATED
+################################################################
+@dataclass
+class InputClass:
+    prompt: str = None
+    attachments: List[str] = None
+
+
+################################################################
+# InputSchema concept class - AUTOGENERATED
+################################################################
+class InputClassSchema(Schema):
+    prompt = fields.String(allow_none=True)
+    attachments = fields.List(fields.String(allow_none=True), allow_none=True)
+
+    @post_load
+    def create(self, data, **kwargs):
+        return SchemaUtil.create(InputClass(), data)

app/ontology_dc8f06af066e4a7880a5938933236037/output.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from marshmallow import Schema, fields, post_load
+
+# Removed import as Resource doesn't exist in this version of openfabric_pysdk
+# from openfabric_pysdk.fields import Resource
+from openfabric_pysdk.utility import SchemaUtil
+
+
+################################################################
+# Output concept class - AUTOGENERATED
+################################################################
+@dataclass
+class OutputClass:
+    message: str = None
+
+
+################################################################
+# OutputSchema concept class - AUTOGENERATED
+################################################################
+class OutputClassSchema(Schema):
+    message = fields.Str(allow_none=True)
+
+    @post_load
+    def create(self, data, **kwargs):
+        return SchemaUtil.create(OutputClass(), data)

app/tools/blob_viewer.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+Openfabric Blob Viewer - A utility for viewing and downloading resources from Openfabric
+
+Usage:
+  python blob_viewer.py view <data_blob_id> [<execution_id>]
+  python blob_viewer.py download <data_blob_id> [<execution_id>]
+
+Examples:
+  # View an image directly in browser
+  python blob_viewer.py view data_blob_1d9d210d20c1e75ea6a3855b6d10341fd8f125b49866b61b7ae94f8fa4bffd49 2d529306be574949a2a3d2f9d9e4082b
+
+  # Download a resource
+  python blob_viewer.py download data_blob_1d9d210d20c1e75ea6a3855b6d10341fd8f125b49866b61b7ae94f8fa4bffd49 2d529306be574949a2a3d2f9d9e4082b
+"""
+
+import os
+import sys
+import argparse
+import webbrowser
+import requests
+from pathlib import Path
+from dotenv import load_dotenv
+import base64
+import json
+from datetime import datetime
+
+# Make sure we can import from our app
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# Load environment variables
+load_dotenv()
+
+# Configure output directory for downloads
+OUTPUT_DIR = Path(__file__).parent.parent / "data" / "downloads"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Get app IDs from environment
+TEXT_TO_IMAGE_APP_ID = os.environ.get("TEXT_TO_IMAGE_APP_ID")
+IMAGE_TO_3D_APP_ID = os.environ.get("IMAGE_TO_3D_APP_ID")
+
+
+def construct_resource_url(data_blob_id, execution_id=None):
+    """
+    Construct the URL for accessing a resource from a data_blob ID
+
+    Args:
+        data_blob_id: The data_blob ID (can be full path or just the ID)
+        execution_id: Optional execution ID
+
+    Returns:
+        URL to access the resource
+    """
+    # Extract the actual blob ID if provided with path format
+    if "/" in data_blob_id:
+        parts = data_blob_id.split("/")
+        data_blob_id = parts[0]
+        if len(parts) > 2 and not execution_id:
+            execution_id = parts[2]
+
+    # Create the reid parameter value
+    reid = data_blob_id
+    if execution_id:
+        reid = f"{data_blob_id}/executions/{execution_id}"
+
+    # Format the URL correctly based on the example
+    base_url = f"https://{TEXT_TO_IMAGE_APP_ID}/resource?reid={reid}"
+
+    return base_url
+
+
+def open_in_browser(data_blob_id, execution_id=None):
+    """Open a resource directly in the web browser"""
+    url = construct_resource_url(data_blob_id, execution_id)
+    print(f"Opening URL in browser: {url}")
+    webbrowser.open(url)
+
+
+def download_resource(
+    data_blob_id, execution_id=None, prompt=None, target_dir=None, metadata=None
+):
+    """
+    Download a resource from the given data_blob ID
+
+    Args:
+        data_blob_id: The data_blob ID
+        execution_id: Optional execution ID
+        prompt: Optional prompt text to use in filename
+        target_dir: Optional target directory to save to (defaults to downloads)
+        metadata: Optional metadata to save alongside the downloaded file
+    """
+    url = construct_resource_url(data_blob_id, execution_id)
+
+    # Use downloads directory as default if not specified
+    if target_dir:
+        output_dir = Path(target_dir)
+    else:
+        output_dir = OUTPUT_DIR
+
+    # Ensure the output directory exists
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        print(f"Downloading from: {url}")
+        response = requests.get(url)
+
+        if response.status_code == 200:
+            # Determine content type and extension
+            content_type = response.headers.get(
+                "Content-Type", "application/octet-stream"
+            )
+
+            # Choose file extension based on content type
+            extension = "bin"  # Default extension
+            if "image/png" in content_type:
+                extension = "png"
+            elif "image/jpeg" in content_type:
+                extension = "jpg"
+            elif (
+                "model/gltf+json" in content_type or "application/json" in content_type
+            ):
+                extension = "gltf"
+            elif "model/gltf-binary" in content_type:
+                extension = "glb"
+
+            # Create filename based on prompt if available
+            if prompt:
+                # Use first 15 chars of prompt, replacing spaces with underscores
+                base_name = prompt[:15].strip().replace(" ", "_").replace("/", "_")
+                # Remove any other non-alphanumeric characters
+                base_name = "".join(c for c in base_name if c.isalnum() or c == "_")
+
+                # Add timestamp for uniqueness
+                timestamp = int(datetime.now().timestamp())
+                filename = f"{base_name}_{timestamp}.{extension}"
+
+                # Also create metadata filename
+                metadata_filename = f"{base_name}_{timestamp}.json"
+            else:
+                # Fallback to timestamp and blob ID if no prompt
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                clean_blob_id = data_blob_id.replace("/", "_")
+
+                if execution_id:
+                    filename = f"{timestamp}_{clean_blob_id[:8]}_{execution_id[:8]}.{extension}"
+                else:
+                    filename = f"{timestamp}_{clean_blob_id[:8]}.{extension}"
+
+                # Also create metadata filename
+                metadata_filename = filename.replace(f".{extension}", ".json")
+
+            output_path = output_dir / filename
+            metadata_path = output_dir / metadata_filename
+
+            # Save the file
+            with open(output_path, "wb") as f:
+                f.write(response.content)
+
+            # Create and save metadata
+            if metadata:
+                metadata["download_timestamp"] = int(datetime.now().timestamp())
+                metadata["download_source"] = url
+                metadata["file_path"] = str(output_path)
+
+                with open(metadata_path, "w") as f:
+                    json.dump(metadata, f, indent=2)
+
+            print(f"Successfully downloaded to: {output_path}")
+            return str(output_path)
+        else:
+            print(f"Failed to download resource. Status code: {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+
+    except Exception as e:
+        print(f"Error downloading resource: {str(e)}")
+        return None
+
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="Openfabric Blob Viewer")
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # View command
+    view_parser = subparsers.add_parser("view", help="View a blob in browser")
+    view_parser.add_argument("data_blob_id", help="Blob ID or full path")
+    view_parser.add_argument("execution_id", nargs="?", help="Execution ID (optional)")
+
+    # Download command
+    download_parser = subparsers.add_parser("download", help="Download a blob")
+    download_parser.add_argument("data_blob_id", help="Blob ID or full path")
+    download_parser.add_argument(
+        "execution_id", nargs="?", help="Execution ID (optional)"
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if not args.command:
+        print(__doc__)
+        return
+
+    if args.command == "view":
+        open_in_browser(args.data_blob_id, args.execution_id)
+    elif args.command == "download":
+        download_resource(args.data_blob_id, args.execution_id)
+    else:
+        print(__doc__)
+
+
+if __name__ == "__main__":
+    main()

app/ui/app.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python
+"""
+AI Creative Application UI - Modified for stability and Hugging Face Spaces compatibility
+"""
+
+import os
+import sys
+import logging
+import time
+import json
+from pathlib import Path
+from dotenv import load_dotenv
+import gradio as gr
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("ui")
+
+# Add the parent directory to sys.path to import app modules
+sys.path.append(str(Path(__file__).parent.parent))
+
+# Set environment variable to disable SSL verification for httpx
+os.environ["HTTPX_VERIFY"] = "0"
+
+# Detect if running in Hugging Face Spaces
+RUNNING_IN_SPACES = os.environ.get("HF_SPACES", "0") == "1"
+
+# Load environment variables if .env exists and not in HF Spaces
+if not RUNNING_IN_SPACES:
+    dotenv_path = Path(__file__).parent.parent.parent / ".env"
+    if dotenv_path.exists():
+        load_dotenv(dotenv_path=dotenv_path)
+        logger.info(f"Loaded environment from {dotenv_path}")
+    else:
+        logger.warning(f".env file not found at {dotenv_path}")
+else:
+    logger.info("Running in Hugging Face Spaces environment")
+
+# Conditionally import app modules with error handling
+try:
+    from core.pipeline import CreativePipeline, PipelineResult
+    from core.stub import Stub
+
+    CORE_MODULES_AVAILABLE = True
+except ImportError as e:
+    logger.error(f"Failed to import core modules: {str(e)}")
+    CORE_MODULES_AVAILABLE = False
+
+# Get app IDs from environment with defaults
+TEXT_TO_IMAGE_APP_ID = os.environ.get(
+    "TEXT_TO_IMAGE_APP_ID", "c25dcd829d134ea98f5ae4dd311d13bc.node3.openfabric.network"
+)
+IMAGE_TO_3D_APP_ID = os.environ.get(
+    "IMAGE_TO_3D_APP_ID", "f0b5f319156c4819b9827000b17e511a.node3.openfabric.network"
+)
+
+
+def main():
+    """AI Creative application interface"""
+
+    # Paths for saving generated content - adjust for HF Spaces environment
+    if RUNNING_IN_SPACES:
+        data_path = Path("/tmp/data")
+    else:
+        data_path = Path(__file__).parent.parent / "data"
+
+    images_path = data_path / "images"
+    models_path = data_path / "models"
+
+    # Ensure necessary directories exist
+    images_path.mkdir(exist_ok=True, parents=True)
+    models_path.mkdir(exist_ok=True, parents=True)
+
+    # Initialize pipeline only if modules are available
+    pipeline = None
+    if CORE_MODULES_AVAILABLE:
+        try:
+            # Configure app IDs - use both TEXT_TO_IMAGE and IMAGE_TO_3D
+            app_ids = []
+            if TEXT_TO_IMAGE_APP_ID:
+                app_ids.append(TEXT_TO_IMAGE_APP_ID)
+            if IMAGE_TO_3D_APP_ID:
+                app_ids.append(IMAGE_TO_3D_APP_ID)
+
+            logger.info(f"Using app IDs: {app_ids}")
+            stub = Stub(app_ids=app_ids)
+            pipeline = CreativePipeline(stub)
+            logger.info("Pipeline initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize pipeline: {str(e)}")
+
+    def generate_from_prompt(prompt, creative_strength=0.7):
+        """
+        Generate image from text prompt - Using a simpler return format to avoid Pydantic issues
+        """
+        if not prompt:
+            return "Please enter a prompt", None, None, "", ""
+
+        if not pipeline:
+            return (
+                "Services not available. Please check server status.",
+                None,
+                None,
+                "",
+                "",
+            )
+
+        try:
+            # Parameters for generation
+            params = {
+                "image": {
+                    "creative_strength": creative_strength,
+                },
+                "model": {"quality": "standard"},
+            }
+
+            # Update status immediately
+            status_msg = "Generating image from your prompt..."
+
+            # Run the creative pipeline
+            result = pipeline.create(prompt, params)
+
+            # Handle failed generation
+            if not result.success and not result.image_path:
+                return "Failed to generate image from prompt", None, None, "", ""
+
+            # Process successful generation
+            image_info = f"Original prompt: {result.original_prompt}\n"
+            if (
+                hasattr(result, "expanded_prompt")
+                and result.expanded_prompt
+                and result.expanded_prompt != result.original_prompt
+            ):
+                image_info += f"Enhanced prompt: {result.expanded_prompt}\n"
+
+            # Check for image path
+            image_path = result.image_path if hasattr(result, "image_path") else None
+
+            # Check for 3D model
+            model_path = (
+                result.model_path
+                if hasattr(result, "model_path") and result.model_path
+                else None
+            )
+            model_info = ""
+
+            if model_path:
+                model_info = f"3D model generated from image.\n"
+                model_info += f"Model format: {Path(model_path).suffix[1:]}"
+                status_msg = "Image and 3D model generated successfully!"
+            else:
+                status_msg = "Image generated successfully!"
+
+            return status_msg, image_path, model_path, image_info, model_info
+
+        except Exception as e:
+            logger.error(f"Generation error: {str(e)}")
+            return f"Error: {str(e)}", None, None, "", ""
+
+    def list_gallery_items():
+        """List available images in the gallery"""
+        images = list(images_path.glob("*.png")) + list(images_path.glob("*.jpg"))
+        return sorted(
+            [(str(img), img.stem) for img in images], key=lambda x: x[1], reverse=True
+        )
+
+    with gr.Blocks(title="AI Creative Studio") as demo:
+        gr.Markdown("# AI Creative Studio")
+        gr.Markdown("Generate images from text descriptions")
+
+        with gr.Tab("Create"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Input area
+                    prompt_input = gr.Textbox(
+                        label="Your creative prompt",
+                        placeholder="Describe what you want to create...",
+                        lines=3,
+                    )
+
+                    with gr.Row():
+                        creative_strength = gr.Slider(
+                            label="Creative Strength",
+                            minimum=0.0,
+                            maximum=1.0,
+                            value=0.7,
+                            step=0.1,
+                        )
+
+                    generate_btn = gr.Button("Generate", variant="primary")
+                    status = gr.Textbox(label="Status", interactive=False)
+
+                with gr.Column(scale=3):
+                    # Output area with tabs for different views
+                    with gr.Tab("Image"):
+                        with gr.Row():
+                            image_output = gr.Image(
+                                label="Generated Image", type="filepath"
+                            )
+                            image_info = gr.Textbox(
+                                label="Image Details", interactive=False, lines=3
+                            )
+
+                    with gr.Tab("3D Model"):
+                        with gr.Row():
+                            model_viewer = gr.Model3D(label="3D Model")
+                            model_info = gr.Textbox(
+                                label="Model Details", interactive=False, lines=3
+                            )
+
+        with gr.Tab("Gallery"):
+            # Function to update the image gallery
+            def update_image_gallery():
+                images = list(images_path.glob("*.png")) + list(
+                    images_path.glob("*.jpg")
+                )
+                return sorted(
+                    [str(img) for img in images],
+                    key=lambda x: os.path.getmtime(x) if os.path.exists(x) else 0,
+                    reverse=True,
+                )
+
+            # Function to update the models gallery and return both the models list and model paths
+            def update_models_gallery():
+                models = list(models_path.glob("*.glb")) + list(
+                    models_path.glob("*.gltf")
+                )
+                model_data = []
+                model_paths = []  # Store just the paths for easy access by index
+
+                for model_path in sorted(
+                    models,
+                    key=lambda x: os.path.getmtime(x) if os.path.exists(x) else 0,
+                    reverse=True,
+                ):
+                    # Try to load metadata file if available
+                    metadata_path = model_path.with_suffix(".json")
+                    creation_time = time.strftime(
+                        "%Y-%m-%d %H:%M", time.localtime(os.path.getmtime(model_path))
+                    )
+
+                    if metadata_path.exists():
+                        try:
+                            with open(metadata_path, "r") as f:
+                                metadata = json.load(f)
+                            source_image = metadata.get(
+                                "source_image_filename", "Unknown"
+                            )
+                            format_type = metadata.get("format", model_path.suffix[1:])
+                        except Exception as e:
+                            logger.error(
+                                f"Failed to read metadata for {model_path}: {e}"
+                            )
+                            source_image = "Unknown"
+                            format_type = model_path.suffix[1:]
+                    else:
+                        source_image = "Unknown"
+                        format_type = model_path.suffix[1:]
+
+                    # Add to data table and path list
+                    model_paths.append(str(model_path))
+                    model_data.append(
+                        [
+                            str(model_path),
+                            source_image,
+                            format_type,
+                            creation_time,
+                        ]
+                    )
+
+                return model_data, model_paths
+
+            # Function to view model by index instead of relying on DataFrame selection
+            def view_model_by_index(evt: gr.SelectData):
+                if (
+                    not hasattr(view_model_by_index, "model_paths")
+                    or not view_model_by_index.model_paths
+                ):
+                    logger.warning("No model paths available")
+                    return None, None
+
+                try:
+                    # Get the index from the selection event
+                    row_index = (
+                        evt.index[0] if hasattr(evt, "index") and evt.index else 0
+                    )
+                    if row_index < 0 or row_index >= len(
+                        view_model_by_index.model_paths
+                    ):
+                        logger.warning(f"Invalid model index: {row_index}")
+                        return None, None
+
+                    # Get the model path from our saved list
+                    model_path = view_model_by_index.model_paths[row_index]
+                    logger.info(f"Selected model at index {row_index}: {model_path}")
+
+                    if not model_path or not os.path.exists(model_path):
+                        logger.warning(f"Model file not found: {model_path}")
+                        return None, None
+
+                except (IndexError, AttributeError, TypeError) as e:
+                    logger.error(f"Error accessing selected model: {e}")
+                    return None, None
+
+                # Get model metadata if available
+                metadata_path = Path(model_path).with_suffix(".json")
+                metadata = {}
+
+                if metadata_path.exists():
+                    try:
+                        with open(metadata_path, "r") as f:
+                            metadata = json.load(f)
+                        logger.info(f"Loaded metadata for model: {model_path}")
+                    except Exception as e:
+                        logger.error(f"Failed to read metadata for {model_path}: {e}")
+                else:
+                    logger.warning(f"No metadata file found for model: {metadata_path}")
+
+                return model_path, metadata
+
+            # Function to store model paths in the view function's namespace
+            def store_model_paths(model_data, model_paths):
+                view_model_by_index.model_paths = model_paths
+                return model_data
+
+            with gr.Tabs() as gallery_tabs:
+                with gr.Tab("Images"):
+                    image_gallery = gr.Gallery(
+                        label="Generated Images",
+                        columns=4,
+                        object_fit="contain",
+                        height="auto",
+                    )
+                    refresh_img_btn = gr.Button("Refresh Images")
+
+                with gr.Tab("3D Models"):
+                    models_list = gr.Dataframe(
+                        headers=["Model", "Source Image", "Format", "Created"],
+                        label="Available 3D Models",
+                        row_count=10,
+                        col_count=(4, "fixed"),
+                        interactive=False,
+                    )
+                    with gr.Row():
+                        selected_model = gr.Model3D(label="Selected 3D Model")
+                        model_details = gr.JSON(label="Model Details")
+
+                    refresh_models_btn = gr.Button("Refresh Models")
+                    # Removed the "View Selected Model" button that was causing errors
+
+                    # Make the dataframe selection trigger the model loading automatically
+                    models_list.select(
+                        fn=view_model_by_index, outputs=[selected_model, model_details]
+                    )
+
+            # Wire up the gallery refresh buttons
+            refresh_img_btn.click(fn=update_image_gallery, outputs=[image_gallery])
+            refresh_models_btn.click(
+                fn=lambda: store_model_paths(*update_models_gallery()),
+                outputs=[models_list],
+            )
+
+            # Removed the view_model_btn.click implementation since we're removing the button
+
+            # Initial gallery loads
+            demo.load(update_image_gallery, outputs=[image_gallery])
+            demo.load(
+                fn=lambda: store_model_paths(*update_models_gallery()),
+                outputs=[models_list],
+            )
+
+        # Wire up the generate button - non-streaming mode to avoid Pydantic issues
+        generate_btn.click(
+            fn=generate_from_prompt,
+            inputs=[prompt_input, creative_strength],
+            outputs=[
+                status,
+                image_output,
+                model_viewer,
+                image_info,
+                model_info,
+            ],
+        )
+
+        # Initial gallery load
+        demo.load(update_image_gallery, outputs=[image_gallery])
+        demo.load(
+            fn=lambda: store_model_paths(*update_models_gallery()),
+            outputs=[models_list],
+        )
+
+    # Launch the UI with parameters compatible with Gradio 4.26.0
+    port = int(os.environ.get("UI_PORT", 7860))
+    logger.info(f"Launching UI on port {port}")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=port,
+        share=True,
+        show_error=True,
+        # Removed api_mode parameter that's not supported in 4.26.0
+    )
+
+
+if __name__ == "__main__":
+    main()

onto/dc8f06af066e4a7880a5938933236037/connection/ConfigClass.json

@@ -0,0 +1,10 @@
+{
+  "$type" : "connection",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "82a958bf5a277217a679c14824974c2f",
+  "$author" : "andrei",
+  "description" : "Define connection for ConfigClass concept",
+  "connections" : { },
+  "locations" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/connection/InputClass.json

@@ -0,0 +1,10 @@
+{
+  "$type" : "connection",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "00f7a3dfaaa9073f029302b9fbb4191e",
+  "$author" : "andrei",
+  "description" : "Define connection for InputClass concept",
+  "connections" : { },
+  "locations" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/connection/OutputClass.json

@@ -0,0 +1,10 @@
+{
+  "$type" : "connection",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "523a8eb9ad1eb66ba6d1add87742cee5",
+  "$author" : "andrei",
+  "description" : "Define connection for OutputClass concept",
+  "connections" : { },
+  "locations" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/defaults/ConfigClass.json

@@ -0,0 +1,15 @@
+{
+  "$type" : "defaults",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "82a958bf5a277217a679c14824974c2f",
+  "$author" : "andrei",
+  "description" : "Define defaults for ConfigClass concept",
+  "locale" : "en_US",
+  "extends" : null,
+  "defaults" : {
+    "app_ids" : "None"
+  },
+  "options" : { },
+  "icons" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/defaults/InputClass.json

@@ -0,0 +1,15 @@
+{
+  "$type" : "defaults",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "00f7a3dfaaa9073f029302b9fbb4191e",
+  "$author" : "andrei",
+  "description" : "Define defaults for InputClass concept",
+  "locale" : "en_US",
+  "extends" : null,
+  "defaults" : {
+    "prompt" : "None"
+  },
+  "options" : { },
+  "icons" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/defaults/OutputClass.json

@@ -0,0 +1,15 @@
+{
+  "$type" : "defaults",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "523a8eb9ad1eb66ba6d1add87742cee5",
+  "$author" : "andrei",
+  "description" : "Define defaults for OutputClass concept",
+  "locale" : "en_US",
+  "extends" : null,
+  "defaults" : {
+    "message" : "None"
+  },
+  "options" : { },
+  "icons" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/encoding/ConfigClass.json

@@ -0,0 +1,10 @@
+{
+  "$type" : "encoding",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "82a958bf5a277217a679c14824974c2f",
+  "$author" : "andrei",
+  "description" : "Define encoding for ConfigClass concept",
+  "default" : "UTF-8",
+  "encodings" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/encoding/InputClass.json

@@ -0,0 +1,10 @@
+{
+  "$type" : "encoding",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "00f7a3dfaaa9073f029302b9fbb4191e",
+  "$author" : "andrei",
+  "description" : "Define encoding for InputClass concept",
+  "default" : "UTF-8",
+  "encodings" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/encoding/OutputClass.json

@@ -0,0 +1,10 @@
+{
+  "$type" : "encoding",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "523a8eb9ad1eb66ba6d1add87742cee5",
+  "$author" : "andrei",
+  "description" : "Define encoding for OutputClass concept",
+  "default" : "UTF-8",
+  "encodings" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/instruction/ConfigClass.json

@@ -0,0 +1,14 @@
+{
+  "$type" : "instruction",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "82a958bf5a277217a679c14824974c2f",
+  "$author" : "andrei",
+  "description" : "Define instruction for ConfigClass concept",
+  "locale" : "en_US",
+  "instructions" : { },
+  "display" : { },
+  "layout" : { },
+  "render" : null,
+  "renderingType" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/instruction/InputClass.json

@@ -0,0 +1,14 @@
+{
+  "$type" : "instruction",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "00f7a3dfaaa9073f029302b9fbb4191e",
+  "$author" : "andrei",
+  "description" : "Define instruction for InputClass concept",
+  "locale" : "en_US",
+  "instructions" : { },
+  "display" : { },
+  "layout" : { },
+  "render" : null,
+  "renderingType" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/instruction/OutputClass.json

@@ -0,0 +1,14 @@
+{
+  "$type" : "instruction",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "523a8eb9ad1eb66ba6d1add87742cee5",
+  "$author" : "andrei",
+  "description" : "Define instruction for OutputClass concept",
+  "locale" : "en_US",
+  "instructions" : { },
+  "display" : { },
+  "layout" : { },
+  "render" : null,
+  "renderingType" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/meta.json

@@ -0,0 +1,42 @@
+{
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$author" : "andrei",
+  "$name" : "test-ai",
+  "$description" : null,
+  "storage" : {
+    "00f7a3dfaaa9073f029302b9fbb4191e" : {
+      "STRUCTURE" : "structure/InputClass.json",
+      "ENCODING" : "encoding/InputClass.json",
+      "SUBSET" : "subset/InputClass.json",
+      "RESTRICTION" : "restriction/InputClass.json",
+      "DEFAULTS" : "defaults/InputClass.json",
+      "VALIDATION" : "validation/InputClass.json",
+      "INSTRUCTION" : "instruction/InputClass.json",
+      "CONNECTION" : "connection/InputClass.json",
+      "NAMING" : "naming/InputClass.json"
+    },
+    "82a958bf5a277217a679c14824974c2f" : {
+      "STRUCTURE" : "structure/ConfigClass.json",
+      "ENCODING" : "encoding/ConfigClass.json",
+      "SUBSET" : "subset/ConfigClass.json",
+      "RESTRICTION" : "restriction/ConfigClass.json",
+      "DEFAULTS" : "defaults/ConfigClass.json",
+      "VALIDATION" : "validation/ConfigClass.json",
+      "INSTRUCTION" : "instruction/ConfigClass.json",
+      "CONNECTION" : "connection/ConfigClass.json",
+      "NAMING" : "naming/ConfigClass.json"
+    },
+    "523a8eb9ad1eb66ba6d1add87742cee5" : {
+      "STRUCTURE" : "structure/OutputClass.json",
+      "ENCODING" : "encoding/OutputClass.json",
+      "SUBSET" : "subset/OutputClass.json",
+      "RESTRICTION" : "restriction/OutputClass.json",
+      "DEFAULTS" : "defaults/OutputClass.json",
+      "VALIDATION" : "validation/OutputClass.json",
+      "INSTRUCTION" : "instruction/OutputClass.json",
+      "CONNECTION" : "connection/OutputClass.json",
+      "NAMING" : "naming/OutputClass.json"
+    }
+  }
+}

onto/dc8f06af066e4a7880a5938933236037/naming/ConfigClass.json

@@ -0,0 +1,12 @@
+{
+  "$type" : "naming",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "82a958bf5a277217a679c14824974c2f",
+  "$author" : "andrei",
+  "description" : "Define naming for ConfigClass concept",
+  "locale" : "en_US",
+  "selfName" : null,
+  "names" : { },
+  "labels" : { }
+}

onto/dc8f06af066e4a7880a5938933236037/naming/InputClass.json

@@ -0,0 +1,12 @@
+{
+  "$type" : "naming",
+  "schema" : "dc8f06af066e4a7880a5938933236037",
+  "$version" : "1.0",
+  "$id" : "00f7a3dfaaa9073f029302b9fbb4191e",
+  "$author" : "andrei",
+  "description" : "Define naming for InputClass concept",
+  "locale" : "en_US",
+  "selfName" : null,
+  "names" : { },
+  "labels" : { }
+}