init

.gitattributes copy

@@ -0,0 +1,38 @@
+*.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
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.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
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/scene.jpg filter=lfs diff=lfs merge=lfs -text
+assets/style.png filter=lfs diff=lfs merge=lfs -text
+assets/subject.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,17 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+image_generate.png
+
+# Virtual environments
+.venv
+.env
+
+
+# Images
+images/

.python-version

@@ -0,0 +1 @@
+3.11

README copy.md

@@ -0,0 +1,12 @@
+---
+title: FIBO Mashup
+emoji: 🏃
+colorFrom: yellow
+colorTo: gray
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api_utils.py

@@ -0,0 +1,174 @@
+import base64
+import io
+import json
+import os
+import time
+from typing import Any, Dict, Optional
+from PIL import Image
+import requests
+
+
+def _image_to_base64(image: Image.Image) -> str:
+    buffer = io.BytesIO()
+    image_format = (image.format or "PNG").upper()
+    if image_format not in {"PNG", "JPEG", "JPG"}:
+        image_format = "PNG"
+    image.save(buffer, format=image_format)
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+
+def _extract_status(payload: Dict[str, Any]) -> Optional[str]:
+    status_info = payload.get("status") or payload.get("state")
+    if isinstance(status_info, dict):
+        state = status_info.get("state") or status_info.get("status")
+        if isinstance(state, str):
+            return state.lower()
+    elif isinstance(status_info, str):
+        return status_info.lower()
+    return None
+
+
+def _poll_bria_status(
+    status_url: str,
+    headers: Dict[str, str],
+    timeout_seconds: int = 120,
+    poll_interval: float = 1.5,
+) -> Dict[str, Any]:
+    deadline = time.time() + timeout_seconds
+    while True:
+        response = requests.get(status_url, headers=headers, timeout=30)
+        response.raise_for_status()
+        payload: Dict[str, Any] = response.json()
+        state = _extract_status(payload)
+
+        if state in {"succeeded", "success", "completed", "done"}:
+            if isinstance(payload.get("result"), dict):
+                return payload["result"]
+            if payload.get("results") is not None:
+                return payload["results"]
+            return payload
+
+        if state in {"failed", "error", "cancelled", "canceled"}:
+            raise RuntimeError(
+                f"Bria VLM API request failed: {json.dumps(payload, indent=2)}"
+            )
+
+        if time.time() > deadline:
+            raise TimeoutError(
+                f"Bria VLM API request timed out while polling {status_url}"
+            )
+
+        time.sleep(poll_interval)
+
+
+def _submit_bria_request(
+    url: str, payload: Dict[str, Any], api_token: str
+) -> Dict[str, Any]:
+    headers = {
+        "Content-Type": "application/json",
+        "api_token": api_token,
+    }
+    response = requests.post(url, json=payload, headers=headers, timeout=30)
+    response.raise_for_status()
+    initial_payload: Dict[str, Any] = response.json()
+
+    status_url = (
+        initial_payload.get("status_url")
+        or initial_payload.get("statusUrl")
+        or (initial_payload.get("status") or {}).get("status_url")
+    )
+
+    if status_url:
+        return _poll_bria_status(status_url, headers)
+
+    if isinstance(initial_payload.get("result"), dict):
+        return initial_payload["result"]
+    if initial_payload.get("results") is not None:
+        return initial_payload["results"]
+
+    return initial_payload
+
+
+def _parse_vlm_response(data: Any, prompt_role: str) -> str:
+    if isinstance(data, dict):
+        direct_match = data.get(prompt_role)
+        if isinstance(direct_match, str):
+            return direct_match
+
+        for key in ("prompt", "structured_prompt", "structuredPrompt", "text"):
+            if key in data:
+                value = data[key]
+                if isinstance(value, str):
+                    return value
+                if isinstance(value, dict):
+                    nested = value.get(prompt_role)
+                    if isinstance(nested, str):
+                        return nested
+
+        for key in ("result", "results"):
+            if key in data:
+                nested_result = _parse_vlm_response(data[key], prompt_role)
+                if nested_result:
+                    return nested_result
+
+    if isinstance(data, list):
+        for item in data:
+            nested_result = _parse_vlm_response(item, prompt_role)
+            if nested_result:
+                return nested_result
+
+    return json.dumps(data)
+
+
+def get_prompt_api(image_path: str, prompt_role: str) -> str:
+    """Send an image to the Bria VLM API and return the extracted prompt text.
+
+    The payload keys are aligned with the current public docs but may require
+    adjustment if your Bria workspace is configured differently. Override the
+    default endpoint via the ``BRIA_API_VLM_ENDPOINT`` environment variable if
+    you are using a custom workflow.
+    """
+    api_token = os.environ.get("BRIA_API_KEY")
+    if not api_token:
+        raise EnvironmentError(
+            "BRIA_API_KEY environment variable is required to use the Bria VLM API."
+        )
+
+    base_url = os.environ.get("BRIA_API_BASE_URL", "https://engine.prod.bria-api.com")
+    endpoint = os.environ.get("BRIA_API_VLM_ENDPOINT", "/v2/structured_prompt/generate")
+    url = f"{base_url.rstrip('/')}{endpoint}"
+
+    # convert image to base64
+    with Image.open(image_path) as image:
+        image_b64 = _image_to_base64(image)
+
+    payload = {"images": [image_b64]}
+
+    response = _submit_bria_request(url, payload, api_token)
+
+    return response["structured_prompt"]
+
+
+def get_image_from_url(image_url: str) -> Image.Image:
+    """Get an image from a URL."""
+    response = requests.get(image_url)
+    return Image.open(io.BytesIO(response.content))
+
+
+def generate_image(prompt: str) -> Image.Image:
+    """Generate an image from a prompt using the Bria VLM API."""
+    api_token = os.environ.get("BRIA_API_KEY")
+    if not api_token:
+        raise EnvironmentError(
+            "BRIA_API_KEY environment variable is required to use the Bria VLM API."
+        )
+
+    base_url = os.environ.get("BRIA_API_BASE_URL", "https://engine.prod.bria-api.com")
+    endpoint = os.environ.get("BRIA_API_GENERATE_ENDPOINT", "/v2/image/generate")
+    url = f"{base_url.rstrip('/')}{endpoint}"
+
+    payload = {"structured_prompt": prompt}
+
+    response = _submit_bria_request(url, payload, api_token)
+
+    return get_image_from_url(response["image_url"])

app.py

@@ -0,0 +1,152 @@
+import gradio as gr
+import tempfile
+import concurrent.futures
+import dotenv
+import os
+from api_utils import get_prompt_api, generate_image
+from schema import claude_structured_output
+import time
+dotenv.load_dotenv()
+
+def get_image_suffix(image):
+            if hasattr(image, 'format') and image.format:
+                return '.' + image.format.lower()
+            if hasattr(image, 'filename') and image.filename:
+                _, ext = os.path.splitext(image.filename)
+                if ext:
+                    return ext.lower()
+            return '.jpg'
+
+def process_images(subject_image, scene_image, style_image):
+    """
+    Process three images and generate a combined image.
+
+    Args:
+        subject_image: PIL Image for the main subject
+        scene_image: PIL Image for the scene/background
+        style_image: PIL Image for the artistic style
+
+    Returns:
+        PIL Image: The generated combined image
+    """
+    if subject_image is None or scene_image is None or style_image is None:
+        raise gr.Error("Please upload all three images (subject, scene, and style)")
+
+    try:
+        # Save images temporarily to pass to the API
+        with tempfile.TemporaryDirectory() as temp_dir:
+            subject_path = os.path.join(temp_dir, "subject" + get_image_suffix(subject_image))
+            scene_path = os.path.join(temp_dir, "scene" + get_image_suffix(scene_image))
+            style_path = os.path.join(temp_dir, "style" + get_image_suffix(style_image))
+            subject_image.save(subject_path)
+            scene_image.save(scene_path)
+            style_image.save(style_path)
+
+            # Get descriptions for each image
+            time_start = time.time()
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future_subject = executor.submit(get_prompt_api, subject_path, "subject")
+                future_scene = executor.submit(get_prompt_api, scene_path, "scene")
+                future_style = executor.submit(get_prompt_api, style_path, "style")
+                subject = future_subject.result()
+                scene = future_scene.result()
+                style = future_style.result()
+            time_end = time.time()
+            print(f"Time taken to get descriptions: {time_end - time_start} seconds")
+        # Create combined prompt
+        prompt = f"""
+place the main subject from the first image description and place it in the scene from the second image description with a style taken from the third image description.
+
+first (subject) image description:
+{subject}
+second (scene) image description:
+{scene}
+third (style) image description:
+{style}
+
+create a new image description that incorporates all of the descriptions.
+put the subject in the scene with the style.
+"""
+
+        # Generate structured output using Claude API
+        time_start = time.time()
+        response = claude_structured_output(prompt)
+        time_end = time.time()
+        print(f"Time taken to generate structured output: {time_end - time_start} seconds")
+        # Generate the final image
+        time_start = time.time()
+        result_image = generate_image(response)
+        time_end = time.time()
+        print(f"Time taken to generate image: {time_end - time_start} seconds")
+
+        return result_image
+
+    except Exception as e:
+        # Clean up temporary files on error
+        if "subject_path" in locals():
+            os.unlink(subject_path)
+        if "scene_path" in locals():
+            os.unlink(scene_path)
+        if "style_path" in locals():
+            os.unlink(style_path)
+        raise gr.Error(f"Error processing images: {str(e)}")
+
+
+# Create Gradio interface
+with gr.Blocks(title="2IM - Image Combination Generator") as demo:
+    gr.Markdown("""
+    # 🎨 FIBO Mashup - Image Combination Generator
+    
+    Combine three images into one:
+    1. **Subject Image**: The main object or person you want in the final image
+    2. **Scene Image**: The background/environment for the final image
+    3. **Style Image**: The artistic style to apply to the final image
+    """)
+
+    with gr.Row():
+        with gr.Column():
+            subject_input = gr.Image(
+                label="Subject Image",
+                type="pil",
+                height=300,
+                value="assets/subject.jpg",
+            )
+            gr.Markdown("*Upload the main subject/object*")
+
+        with gr.Column():
+            scene_input = gr.Image(
+                label="Scene Image", type="pil", height=300, value="assets/scene.jpg"
+            )
+            gr.Markdown("*Upload the scene/background*")
+
+        with gr.Column():
+            style_input = gr.Image(
+                label="Style Image", type="pil", height=300, value="assets/style.png"
+            )
+            gr.Markdown("*Upload the style reference*")
+
+    generate_btn = gr.Button("🎨 Generate Combined Image", variant="primary", size="lg")
+
+    gr.Markdown("---")
+
+    output_image = gr.Image(label="Generated Image", type="pil", height=500)
+
+    # Set up the event handler
+    generate_btn.click(
+        fn=process_images,
+        inputs=[subject_input, scene_input, style_input],
+        outputs=output_image,
+    )
+
+    gr.Markdown("""
+    ### How it works:
+    1. Upload three images using the fields above
+    2. Click "Generate Combined Image"
+    3. The AI will analyze each image and create a new image that combines the subject from the first image, places it in the scene from the second image, and applies the style from the third image
+    
+    *Note: Generation may take a minute or two depending on API response times.*
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=3.36.1
+pillow>=12.0.0
+setuptools>=80.9.0
+pydantic>=2.12.3
+pydantic-ai>=1.11.0

schema.py

@@ -0,0 +1,216 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent
+
+
+class ObjectDescription(BaseModel):
+    description: str = Field(..., description="Short description of the object.")
+    location: str = Field(
+        ..., description="E.g., 'center', 'top-left', 'bottom-right foreground'."
+    )
+    relationship: str = Field(
+        ...,
+        description="Describe the relationship between the object and the other objects in the image.",
+    )
+    relative_size: Optional[str] = Field(
+        None, description="E.g., 'small', 'medium', 'large within frame'."
+    )
+    shape_and_color: Optional[str] = Field(
+        None, description="Describe the basic shape and dominant color."
+    )
+    texture: Optional[str] = Field(
+        None, description="E.g., 'smooth', 'rough', 'metallic', 'furry'."
+    )
+    appearance_details: Optional[str] = Field(
+        None, description="Any other notable visual details."
+    )
+    # If cluster of object
+    number_of_objects: Optional[int] = Field(
+        None, description="The number of objects in the cluster."
+    )
+    # Human-specific fields
+    pose: Optional[str] = Field(None, description="Describe the body position.")
+    expression: Optional[str] = Field(None, description="Describe facial expression.")
+    clothing: Optional[str] = Field(None, description="Describe attire.")
+    action: Optional[str] = Field(None, description="Describe the action of the human.")
+    gender: Optional[str] = Field(None, description="Describe the gender of the human.")
+    skin_tone_and_texture: Optional[str] = Field(
+        None, description="Describe the skin tone and texture."
+    )
+    orientation: Optional[str] = Field(
+        None, description="Describe the orientation of the human."
+    )
+
+
+class LightingDetails(BaseModel):
+    conditions: str = Field(
+        ...,
+        description="E.g., 'bright daylight', 'dim indoor', 'studio lighting', 'golden hour'.",
+    )
+    direction: str = Field(
+        ..., description="E.g., 'front-lit', 'backlit', 'side-lit from left'."
+    )
+    shadows: Optional[str] = Field(
+        None, description="Describe the presence of shadows."
+    )
+
+
+class AestheticsDetails(BaseModel):
+    composition: str = Field(
+        ...,
+        description="E.g., 'rule of thirds', 'symmetrical', 'centered', 'leading lines'.",
+    )
+    color_scheme: str = Field(
+        ...,
+        description="E.g., 'monochromatic blue', 'warm complementary colors', 'high contrast'.",
+    )
+    mood_atmosphere: str = Field(
+        ..., description="E.g., 'serene', 'energetic', 'mysterious', 'joyful'."
+    )
+
+
+class PhotographicCharacteristicsDetails(BaseModel):
+    depth_of_field: str = Field(
+        ..., description="E.g., 'shallow', 'deep', 'bokeh background'."
+    )
+    focus: str = Field(
+        ..., description="E.g., 'sharp focus on subject', 'soft focus', 'motion blur'."
+    )
+    camera_angle: str = Field(
+        ..., description="E.g., 'eye-level', 'low angle', 'high angle', 'dutch angle'."
+    )
+    lens_focal_length: str = Field(
+        ..., description="E.g., 'wide-angle', 'telephoto', 'macro', 'fisheye'."
+    )
+
+
+class TextRender(BaseModel):
+    text: str = Field(..., description="The text content.")
+    location: str = Field(
+        ..., description="E.g., 'center', 'top-left', 'bottom-right foreground'."
+    )
+    size: str = Field(..., description="E.g., 'small', 'medium', 'large within frame'.")
+    color: str = Field(..., description="E.g., 'red', 'blue', 'green'.")
+    font: str = Field(..., description="E.g., 'realistic', 'cartoonish', 'minimalist'.")
+    appearance_details: Optional[str] = Field(
+        None, description="Any other notable visual details."
+    )
+
+
+class ImageAnalysis(BaseModel):
+    short_description: str = Field(
+        ..., description="A concise summary of the image content, 200 words maximum."
+    )
+    objects: List[ObjectDescription] = Field(
+        ..., description="List of prominent foreground/midground objects."
+    )
+    background_setting: str = Field(
+        ...,
+        description="Describe the overall environment, setting, or background, including any notable background elements.",
+    )
+    lighting: LightingDetails = Field(..., description="Details about the lighting.")
+    aesthetics: AestheticsDetails = Field(
+        ..., description="Details about the image aesthetics."
+    )
+    photographic_characteristics: Optional[PhotographicCharacteristicsDetails] = Field(
+        None, description="Details about photographic characteristics."
+    )
+    style_medium: Optional[str] = Field(
+        None, description="Identify the artistic style or medium."
+    )
+    text_render: Optional[List[TextRender]] = Field(
+        None, description="List of text renders in the image."
+    )
+    context: str = Field(
+        ...,
+        description="Provide any additional context that helps understand the image better.",
+    )
+    artistic_style: Optional[str] = Field(
+        None, description="describe specific artistic characteristics, 3 words maximum."
+    )
+
+
+json_schema_full = """1.  `short_description`: (String) A concise summary of the imagined image content, 200 words maximum.
+2.  `objects`: (Array of Objects) List a maximum of 5 prominent objects. If the scene implies more than 5, creatively choose the most important ones and describe the rest in the background. For each object, include:
+    * `description`: (String) A detailed description of the imagined object, 100 words maximum.
+    * `location`: (String) E.g., "center", "top-left", "bottom-right foreground".
+    * `relative_size`: (String) E.g., "small", "medium", "large within frame". (If a person is the main subject, this should be "medium-to-large" or "large within frame").
+    * `shape_and_color`: (String) Describe the basic shape and dominant color.
+    * `texture`: (String) E.g., "smooth", "rough", "metallic", "furry".
+    * `appearance_details`: (String) Any other notable visual details.
+    * `relationship`: (String) Describe the relationship between the object and the other objects in the image.
+    * `orientation`: (String) Describe the orientation or positioning of the object, e.g., "upright", "tilted 45 degrees", "horizontal", "vertical", "facing left", "facing right", "upside down", "lying on its side".
+    * If the object is a human or a human-like object, include the following:
+        * `pose`: (String) Describe the body position.
+        * `expression`: (String) Describe facial expression and emotion. E.g., "winking", "joyful", "serious", "surprised", "calm".
+        * `clothing`: (String) Describe attire.
+        * `action`: (String) Describe the action of the human.
+        * `gender`: (String) Describe the gender of the human.
+        * `skin_tone_and_texture`: (String) Describe the skin tone and texture.
+    * If the object is a cluster of objects, include the following:
+        * `number_of_objects`: (Integer) The number of objects in the cluster.
+3.  `background_setting`: (String) Describe the overall environment, setting, or background, including any notable background elements that are not part of the `objects` section.
+4.  `lighting`: (Object)
+    * `conditions`: (String) E.g., "bright daylight", "dim indoor", "studio lighting", "golden hour".
+    * `direction`: (String) E.g., "front-lit", "backlit", "side-lit from left".
+    * `shadows`: (String) Describe the presence and quality of shadows, e.g., "long, soft shadows", "sharp, defined shadows", "minimal shadows".
+5.  `aesthetics`: (Object)
+    * `composition`: (String) E.g., "rule of thirds", "symmetrical", "centered", "leading lines". If people are the main subject, specify the shot type, e.g., "medium shot", "close-up", "portrait composition".
+    * `color_scheme`: (String) E.g., "monochromatic blue", "warm complementary colors", "high contrast".
+    * `mood_atmosphere`: (String) E.g., "serene", "energetic", "mysterious", "joyful".
+6.  `photographic_characteristics`: (Object)
+    * `depth_of_field`: (String) E.g., "shallow", "deep", "bokeh background".
+    * `focus`: (String) E.g., "sharp focus on subject", "soft focus", "motion blur".
+    * `camera_angle`: (String) E.g., "eye-level", "low angle", "high angle", "dutch angle".
+    * `lens_focal_length`: (String) E.g., "wide-angle", "telephoto", "macro", "fisheye". (If the main subject is a person, prefer "standard lens (e.g., 35mm-50mm)" or "portrait lens (e.g., 50mm-85mm)" to ensure they are framed more closely. Avoid "wide-angle" for people unless specified).
+7.  `style_medium`: (String) Identify the artistic style or medium based on the user's prompt or creative interpretation (e.g., "photograph", "oil painting", "watercolor", "3D render", "digital illustration", "pencil sketch").
+8.  `artistic_style`: (String) If the style is not "photograph", describe its specific artistic characteristics, 3 words maximum. (e.g., "impressionistic, vibrant, textured" for an oil painting).
+9.  `context`: (String) Provide a general description of the type of image this would be. For example: "This is a concept for a high-fashion editorial photograph intended for a magazine spread," or "This describes a piece of concept art for a fantasy video game."
+10. `text_render`: (Array of Objects) By default, this array should be empty (`[]`). Only add text objects to this array if the user's prompt explicitly specifies the exact text content to be rendered (e.g., user asks for "a poster with the title 'Cosmic Dream'"). Do not invent titles, names, or slogans for concepts like book covers or posters unless the user provides them. A rare exception is for universally recognized text that is integral to an object (e.g., the word 'STOP' on a 'stop sign'). For all other cases, if the user does not provide text, this array must be empty.
+    * `text`: (String) The exact text content provided by the user. NEVER use generic placeholders.
+    * `location`: (String) E.g., "center", "top-left", "bottom-right foreground".
+    * `size`: (String) E.g., "medium", "large", "large within frame".
+    * `color`: (String) E.g., "red", "blue", "green".
+    * `font`: (String) E.g., "realistic", "cartoonish", "minimalist", "serif typeface".
+    * `appearance_details`: (String) Any other notable visual details."""
+
+
+def get_system_prompt() -> str:
+    return f"""You are a Meticulous Visual Editor and Senior Art Director at a leading Generative AI company.
+        Your expertise is in combining multiple image descriptions into a single image description.
+        Your primary task is to receive multiple image descriptions and generate a single image description that incorporates all of the descriptions.
+        Adhere strictly to the following structure and guidelines:
+        1.  **Input:** You will receive three image descriptions. The first image description is the main subject, the second image description is the scene, and the third image description is the style.
+        2.  **Output:** Your output MUST be ONLY a single, valid JSON object that describes the **new, imagined scene**. Do not describe the original reference image.
+        3.  **Modification Logic:**
+            * Carefully parse the three image descriptions to understand the desired changes.
+            * Combine the three image descriptions into a single image description that incorporates all of the descriptions.
+            * The image description should be in the same format as the image descriptions provided.
+            * The image description should be a single, valid image description that incorporates all of the descriptions.
+            * The image description should be a single, valid image description that incorporates all of the descriptions.
+        4.  **Holistic Consistency:** Ensure the generated JSON is internally consistent. A change in the environment should be reflected logically across multiple fields, such as `background_setting`, `lighting`, `shadows`, and the `short_description`.
+        5.  **Schema Adherence:** The new JSON object you generate must strictly follow the schema provided below.
+        The JSON object must contain the following keys precisely:
+        {json_schema_full}"""
+
+
+def claude_structured_output(prompt: str) -> str:
+    """
+    Call Claude API with a prompt and return structured output using a Pydantic schema.
+
+    Args:
+        prompt: The user prompt/query to send to Claude
+
+    Returns:
+        A JSON string with the structured response
+    """
+    system_prompt = get_system_prompt()
+    agent = Agent(
+        "anthropic:claude-sonnet-4-5",
+        output_type=ImageAnalysis,
+        system_prompt=system_prompt,
+    )
+
+    response_text = agent.run_sync(prompt)
+    return response_text.output.model_dump_json()