vibe-aigc 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

vibe_aigc/__init__.py

@@ -98,4 +98,6 @@ __all__ = [
     "create_default_agents",
     # Asset Bank
     "AssetBank", "Character", "StyleGuide", "Artifact", "create_asset_bank"
-]
+]
+# ComfyUI backend for actual image generation
+from .comfyui import ComfyUIBackend, ComfyUIConfig, ComfyUIImageTool, create_comfyui_registry

vibe_aigc/comfyui.py

@@ -0,0 +1,447 @@
+"""ComfyUI backend for actual image/video generation.
+
+This implements the paper's vision of AIGC - AI Generated Content,
+not just text orchestration but actual multimodal content generation.
+"""
+
+import asyncio
+import json
+import uuid
+import aiohttp
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ComfyUIConfig:
+    """Configuration for ComfyUI connection."""
+    host: str = "127.0.0.1"
+    port: int = 8188
+    output_dir: Optional[str] = None  # Where to save generated images
+    
+    @property
+    def base_url(self) -> str:
+        return f"http://{self.host}:{self.port}"
+
+
+@dataclass 
+class GenerationResult:
+    """Result from a ComfyUI generation."""
+    success: bool
+    images: List[str] = field(default_factory=list)  # Paths or URLs to generated images
+    prompt_id: Optional[str] = None
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class ComfyUIBackend:
+    """Backend for interacting with ComfyUI for image/video generation.
+    
+    This enables vibe-aigc to generate actual content, not just orchestrate.
+    """
+    
+    def __init__(self, config: Optional[ComfyUIConfig] = None):
+        self.config = config or ComfyUIConfig()
+        self._client_id = str(uuid.uuid4())
+        
+    async def is_available(self) -> bool:
+        """Check if ComfyUI is running and accessible."""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.config.base_url}/system_stats",
+                    timeout=aiohttp.ClientTimeout(total=5)
+                ) as resp:
+                    return resp.status == 200
+        except Exception:
+            return False
+    
+    async def get_system_stats(self) -> Dict[str, Any]:
+        """Get ComfyUI system stats including GPU info."""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{self.config.base_url}/system_stats") as resp:
+                return await resp.json()
+    
+    async def get_available_models(self) -> Dict[str, List[str]]:
+        """Get available models (checkpoints, loras, etc.)."""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{self.config.base_url}/object_info") as resp:
+                obj_info = await resp.json()
+        
+        models = {}
+        
+        # Extract checkpoint models
+        if "CheckpointLoaderSimple" in obj_info:
+            ckpt_info = obj_info["CheckpointLoaderSimple"]
+            if "input" in ckpt_info and "required" in ckpt_info["input"]:
+                ckpt_input = ckpt_info["input"]["required"].get("ckpt_name", [])
+                if isinstance(ckpt_input, list) and len(ckpt_input) > 0:
+                    if isinstance(ckpt_input[0], list):
+                        models["checkpoints"] = ckpt_input[0]
+        
+        return models
+    
+    async def generate_image(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        width: int = 512,
+        height: int = 512,
+        steps: int = 20,
+        cfg: float = 7.0,
+        seed: Optional[int] = None,
+        checkpoint: Optional[str] = None,
+    ) -> GenerationResult:
+        """Generate an image using ComfyUI's txt2img workflow.
+        
+        Args:
+            prompt: Positive prompt describing what to generate
+            negative_prompt: What to avoid in the generation
+            width: Image width
+            height: Image height  
+            steps: Number of sampling steps
+            cfg: Classifier-free guidance scale
+            seed: Random seed (None for random)
+            checkpoint: Model checkpoint to use (None for default)
+            
+        Returns:
+            GenerationResult with paths to generated images
+        """
+        if seed is None:
+            import random
+            seed = random.randint(0, 2**32 - 1)
+        
+        # Build the workflow
+        workflow = self._build_txt2img_workflow(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=width,
+            height=height,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            checkpoint=checkpoint
+        )
+        
+        return await self._execute_workflow(workflow)
+    
+    async def generate_image_from_image(
+        self,
+        image_path: str,
+        prompt: str,
+        negative_prompt: str = "",
+        denoise: float = 0.75,
+        steps: int = 20,
+        cfg: float = 7.0,
+        seed: Optional[int] = None,
+    ) -> GenerationResult:
+        """Generate an image using img2img workflow.
+        
+        Args:
+            image_path: Path to input image
+            prompt: Positive prompt
+            negative_prompt: Negative prompt
+            denoise: Denoising strength (0-1, higher = more change)
+            steps: Sampling steps
+            cfg: Guidance scale
+            seed: Random seed
+            
+        Returns:
+            GenerationResult with paths to generated images
+        """
+        # TODO: Implement img2img workflow
+        # This requires uploading the image first via /upload/image
+        raise NotImplementedError("img2img not yet implemented")
+    
+    def _build_txt2img_workflow(
+        self,
+        prompt: str,
+        negative_prompt: str,
+        width: int,
+        height: int,
+        steps: int,
+        cfg: float,
+        seed: int,
+        checkpoint: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Build a txt2img workflow in ComfyUI API format."""
+        
+        # Default checkpoint if not specified
+        if checkpoint is None:
+            checkpoint = "v1-5-pruned-emaonly.safetensors"
+        
+        workflow = {
+            "3": {
+                "class_type": "KSampler",
+                "inputs": {
+                    "cfg": cfg,
+                    "denoise": 1,
+                    "latent_image": ["5", 0],
+                    "model": ["4", 0],
+                    "negative": ["7", 0],
+                    "positive": ["6", 0],
+                    "sampler_name": "euler",
+                    "scheduler": "normal",
+                    "seed": seed,
+                    "steps": steps
+                }
+            },
+            "4": {
+                "class_type": "CheckpointLoaderSimple",
+                "inputs": {
+                    "ckpt_name": checkpoint
+                }
+            },
+            "5": {
+                "class_type": "EmptyLatentImage",
+                "inputs": {
+                    "batch_size": 1,
+                    "height": height,
+                    "width": width
+                }
+            },
+            "6": {
+                "class_type": "CLIPTextEncode",
+                "inputs": {
+                    "clip": ["4", 1],
+                    "text": prompt
+                }
+            },
+            "7": {
+                "class_type": "CLIPTextEncode",
+                "inputs": {
+                    "clip": ["4", 1],
+                    "text": negative_prompt
+                }
+            },
+            "8": {
+                "class_type": "VAEDecode",
+                "inputs": {
+                    "samples": ["3", 0],
+                    "vae": ["4", 2]
+                }
+            },
+            "9": {
+                "class_type": "SaveImage",
+                "inputs": {
+                    "filename_prefix": "vibe_aigc",
+                    "images": ["8", 0]
+                }
+            }
+        }
+        
+        return workflow
+    
+    async def _execute_workflow(self, workflow: Dict[str, Any]) -> GenerationResult:
+        """Execute a workflow and wait for completion."""
+        prompt_id = str(uuid.uuid4())
+        
+        payload = {
+            "prompt": workflow,
+            "client_id": self._client_id
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                # Queue the prompt
+                async with session.post(
+                    f"{self.config.base_url}/prompt",
+                    json=payload
+                ) as resp:
+                    if resp.status != 200:
+                        error_text = await resp.text()
+                        return GenerationResult(
+                            success=False,
+                            error=f"Failed to queue prompt: {error_text}"
+                        )
+                    result = await resp.json()
+                    prompt_id = result.get("prompt_id", prompt_id)
+                
+                # Wait for completion by polling history
+                images = await self._wait_for_completion(session, prompt_id)
+                
+                return GenerationResult(
+                    success=True,
+                    images=images,
+                    prompt_id=prompt_id,
+                    metadata={"workflow": workflow}
+                )
+                
+        except Exception as e:
+            return GenerationResult(
+                success=False,
+                error=str(e)
+            )
+    
+    async def _wait_for_completion(
+        self,
+        session: aiohttp.ClientSession,
+        prompt_id: str,
+        timeout: float = 300,
+        poll_interval: float = 0.5
+    ) -> List[str]:
+        """Wait for a prompt to complete and return output images."""
+        import time
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            async with session.get(f"{self.config.base_url}/history/{prompt_id}") as resp:
+                if resp.status == 200:
+                    history = await resp.json()
+                    
+                    if prompt_id in history:
+                        prompt_data = history[prompt_id]
+                        
+                        # Check if completed
+                        if prompt_data.get("status", {}).get("completed", False):
+                            # Extract image paths from outputs
+                            images = []
+                            outputs = prompt_data.get("outputs", {})
+                            
+                            for node_id, node_output in outputs.items():
+                                if "images" in node_output:
+                                    for img in node_output["images"]:
+                                        filename = img.get("filename")
+                                        subfolder = img.get("subfolder", "")
+                                        if filename:
+                                            # Build the view URL
+                                            img_url = f"{self.config.base_url}/view?filename={filename}"
+                                            if subfolder:
+                                                img_url += f"&subfolder={subfolder}"
+                                            images.append(img_url)
+                            
+                            return images
+            
+            await asyncio.sleep(poll_interval)
+        
+        raise TimeoutError(f"Generation timed out after {timeout}s")
+    
+    async def download_image(self, url: str, output_path: str) -> str:
+        """Download a generated image to a local file."""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as resp:
+                if resp.status == 200:
+                    content = await resp.read()
+                    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+                    with open(output_path, "wb") as f:
+                        f.write(content)
+                    return output_path
+                else:
+                    raise RuntimeError(f"Failed to download image: {resp.status}")
+
+
+# Integration with vibe-aigc tools system
+from .tools import BaseTool, ToolResult, ToolSpec, ToolCategory
+
+
+class ComfyUIImageTool(BaseTool):
+    """Tool for generating images via ComfyUI.
+    
+    This is the actual content generation that makes vibe-aigc
+    a true AIGC system, not just text orchestration.
+    """
+    
+    def __init__(self, config: Optional[ComfyUIConfig] = None):
+        self.backend = ComfyUIBackend(config)
+        self._spec = ToolSpec(
+            name="comfyui_image",
+            description="Generate images using ComfyUI (local Stable Diffusion)",
+            category=ToolCategory.IMAGE,
+            input_schema={
+                "type": "object",
+                "required": ["prompt"],
+                "properties": {
+                    "prompt": {"type": "string", "description": "Image generation prompt"},
+                    "negative_prompt": {"type": "string", "description": "What to avoid"},
+                    "width": {"type": "integer", "default": 512},
+                    "height": {"type": "integer", "default": 512},
+                    "steps": {"type": "integer", "default": 20},
+                    "cfg": {"type": "number", "default": 7.0},
+                    "seed": {"type": "integer", "description": "Random seed"},
+                    "checkpoint": {"type": "string", "description": "Model checkpoint"}
+                }
+            },
+            output_schema={
+                "type": "object",
+                "properties": {
+                    "images": {"type": "array", "items": {"type": "string"}},
+                    "prompt_id": {"type": "string"}
+                }
+            }
+        )
+    
+    @property
+    def spec(self) -> ToolSpec:
+        return self._spec
+    
+    async def execute(
+        self,
+        inputs: Dict[str, Any],
+        context: Optional[Dict[str, Any]] = None
+    ) -> ToolResult:
+        """Execute image generation.
+        
+        Args:
+            inputs: Must contain 'prompt', optionally:
+                - negative_prompt
+                - width, height
+                - steps, cfg
+                - seed
+                - checkpoint
+        """
+        prompt = inputs.get("prompt", "")
+        if not prompt:
+            return ToolResult(
+                success=False,
+                output=None,
+                error="No prompt provided"
+            )
+        
+        # Check if ComfyUI is available
+        if not await self.backend.is_available():
+            return ToolResult(
+                success=False,
+                output=None,
+                error="ComfyUI is not running. Start it at http://127.0.0.1:8188"
+            )
+        
+        result = await self.backend.generate_image(
+            prompt=prompt,
+            negative_prompt=inputs.get("negative_prompt", ""),
+            width=inputs.get("width", 512),
+            height=inputs.get("height", 512),
+            steps=inputs.get("steps", 20),
+            cfg=inputs.get("cfg", 7.0),
+            seed=inputs.get("seed"),
+            checkpoint=inputs.get("checkpoint")
+        )
+        
+        if result.success:
+            return ToolResult(
+                success=True,
+                output={
+                    "images": result.images,
+                    "prompt_id": result.prompt_id
+                },
+                metadata=result.metadata
+            )
+        else:
+            return ToolResult(
+                success=False,
+                output=None,
+                error=result.error
+            )
+
+
+def create_comfyui_registry(config: Optional[ComfyUIConfig] = None):
+    """Create a tool registry with ComfyUI tools.
+    
+    This adds actual content generation capabilities to vibe-aigc.
+    """
+    from .tools import ToolRegistry
+    
+    registry = ToolRegistry()
+    registry.register(ComfyUIImageTool(config))
+    
+    return registry

vibe_aigc/knowledge.py

@@ -63,6 +63,7 @@ class KnowledgeBase:
         self._load_writing_knowledge()
         self._load_design_knowledge()
         self._load_music_knowledge()
+        self._load_visual_generation_knowledge()
     
     def _load_film_knowledge(self) -> None:
         """Film/video production knowledge."""
@@ -269,6 +270,182 @@ class KnowledgeBase:
         
         self._domains["music"] = music
     
+    def _load_visual_generation_knowledge(self) -> None:
+        """Visual/image generation knowledge for Stable Diffusion & ComfyUI."""
+        visual = DomainKnowledge(domain="visual")
+        
+        # === AESTHETIC STYLES ===
+        visual.add_concept(
+            name="cyberpunk",
+            description="Futuristic dystopian aesthetic with neon and tech",
+            technical_specs={
+                "sd_prompt_tags": ["cyberpunk", "neon lights", "futuristic city", "rain", 
+                                   "holographic displays", "chrome", "dystopian"],
+                "color_palette": ["#FF00FF", "#00FFFF", "#FF0080", "#00FF80", "#1a1a2e"],
+                "lighting": ["neon glow", "rim lighting", "volumetric fog", "light rays"],
+                "composition": ["low angle", "wide shot", "reflective surfaces"],
+                "negative_prompt": ["natural lighting", "daytime", "pastoral", "bright colors"]
+            },
+            examples=["Blade Runner", "Ghost in the Shell", "Akira"]
+        )
+        
+        visual.add_concept(
+            name="neon noir",
+            description="Modern noir with neon lighting and rain-slicked streets",
+            technical_specs={
+                "sd_prompt_tags": ["neon noir", "rain", "night city", "wet streets",
+                                   "reflections", "moody", "cinematic lighting"],
+                "color_palette": ["#FF00FF", "#00FFFF", "#1a1a2e", "#2d132c"],
+                "lighting": ["neon signs", "puddle reflections", "dramatic shadows", "rim light"],
+                "composition": ["dutch angle", "silhouettes", "deep shadows"],
+                "negative_prompt": ["bright", "cheerful", "daytime", "sunny"]
+            }
+        )
+        
+        visual.add_concept(
+            name="anime",
+            description="Japanese animation style",
+            technical_specs={
+                "sd_prompt_tags": ["anime", "cel shading", "vibrant colors", 
+                                   "detailed eyes", "dramatic pose"],
+                "models": ["anything-v5", "counterfeit-v3", "waifu-diffusion"],
+                "cfg_scale": 7,
+                "negative_prompt": ["realistic", "photographic", "3d render", "western"]
+            }
+        )
+        
+        visual.add_concept(
+            name="photorealistic",
+            description="Realistic, photo-quality images",
+            technical_specs={
+                "sd_prompt_tags": ["photorealistic", "hyperrealistic", "8k", "uhd",
+                                   "RAW photo", "dslr", "soft lighting", "high detail"],
+                "models": ["realistic-vision", "deliberate", "photon"],
+                "cfg_scale": 5,
+                "steps": 30,
+                "negative_prompt": ["cartoon", "anime", "painting", "illustration", 
+                                   "drawing", "artificial", "fake"]
+            }
+        )
+        
+        visual.add_concept(
+            name="cinematic",
+            description="Movie-quality visuals with dramatic lighting",
+            technical_specs={
+                "sd_prompt_tags": ["cinematic", "dramatic lighting", "film grain",
+                                   "anamorphic", "depth of field", "bokeh", "lens flare"],
+                "aspect_ratio": "21:9 or 16:9",
+                "lighting": ["three-point lighting", "golden hour", "blue hour", "volumetric"],
+                "composition": ["rule of thirds", "leading lines", "depth layers"]
+            }
+        )
+        
+        visual.add_concept(
+            name="concept art",
+            description="Professional concept art style for games/films",
+            technical_specs={
+                "sd_prompt_tags": ["concept art", "digital painting", "artstation",
+                                   "trending on artstation", "matte painting", "detailed"],
+                "artists": ["greg rutkowski", "craig mullins", "feng zhu"],
+                "negative_prompt": ["photo", "realistic", "amateur"]
+            }
+        )
+        
+        visual.add_concept(
+            name="portrait",
+            description="Character portrait focus",
+            technical_specs={
+                "sd_prompt_tags": ["portrait", "headshot", "face focus", "detailed face",
+                                   "sharp focus", "studio lighting"],
+                "composition": ["centered", "eye level", "close-up"],
+                "lighting": ["rembrandt lighting", "butterfly lighting", "split lighting"],
+                "negative_prompt": ["full body", "wide shot", "multiple people", "crowd"]
+            }
+        )
+        
+        # === QUALITY MODIFIERS ===
+        visual.add_concept(
+            name="high quality",
+            description="Quality boosting prompt modifiers",
+            technical_specs={
+                "sd_prompt_tags": ["masterpiece", "best quality", "highly detailed", 
+                                   "sharp focus", "intricate details", "professional"],
+                "negative_prompt": ["worst quality", "low quality", "blurry", "jpeg artifacts",
+                                   "watermark", "signature", "text", "error", "cropped"]
+            }
+        )
+        
+        # === LIGHTING TECHNIQUES ===
+        visual.add_technique("dramatic lighting", [
+            "Add 'dramatic lighting' or 'cinematic lighting' to prompt",
+            "Include specific light source (neon, golden hour, etc.)",
+            "Add 'volumetric lighting' or 'god rays' for atmosphere",
+            "Use high contrast in composition"
+        ])
+        
+        visual.add_technique("neon lighting", [
+            "Specify neon colors: 'pink neon', 'cyan neon', 'purple neon'",
+            "Add 'neon glow', 'neon signs', 'neon reflections'",
+            "Include 'wet streets' or 'rain' for reflections",
+            "Set scene at night for contrast"
+        ])
+        
+        # === COMFYUI WORKFLOW KNOWLEDGE ===
+        visual.add_concept(
+            name="txt2img",
+            description="Text to image generation workflow",
+            technical_specs={
+                "nodes": ["CheckpointLoaderSimple", "CLIPTextEncode", "KSampler", 
+                         "VAEDecode", "SaveImage"],
+                "optimal_settings": {
+                    "steps": "20-30 for quality, 10-15 for speed",
+                    "cfg": "7-8 for balanced, 5-6 for creative, 10+ for strict",
+                    "sampler": "euler_ancestral for variety, dpm++ for quality"
+                }
+            }
+        )
+        
+        visual.add_concept(
+            name="img2img",
+            description="Image to image transformation workflow",
+            technical_specs={
+                "nodes": ["LoadImage", "VAEEncode", "KSampler", "VAEDecode", "SaveImage"],
+                "optimal_settings": {
+                    "denoise": "0.4-0.6 for subtle changes, 0.7-0.9 for major changes",
+                    "steps": "20-30",
+                    "cfg": "7-10"
+                }
+            }
+        )
+        
+        visual.add_concept(
+            name="character consistency",
+            description="Maintaining character appearance across generations",
+            technical_specs={
+                "techniques": ["IPAdapter", "reference image", "trained LoRA"],
+                "nodes": ["IPAdapter", "IPAdapterFaceID", "ControlNet"],
+                "tips": ["Use same seed for similar poses", "Train character LoRA for best results"]
+            }
+        )
+        
+        # === CONSTRAINTS ===
+        visual.add_constraint("8gb vram", [
+            "Use SD 1.5 or SDXL with optimizations",
+            "Enable --lowvram or --medvram flags",
+            "Max resolution ~768x768 for SD1.5, ~1024x1024 for SDXL",
+            "Use fp8 for Flux models",
+            "Avoid large batch sizes"
+        ])
+        
+        visual.add_constraint("video generation", [
+            "AnimateDiff for short clips (16-32 frames)",
+            "CogVideoX for longer content (requires more VRAM)",
+            "Keep consistent seed and prompt for coherence",
+            "Use motion LoRA for specific movements"
+        ])
+        
+        self._domains["visual"] = visual
+    
     def register_domain(self, knowledge: DomainKnowledge) -> None:
         """Register a custom domain knowledge module."""
         self._domains[knowledge.domain.lower()] = knowledge

vibe_aigc/llm.py

@@ -16,6 +16,7 @@ class LLMConfig(BaseModel):
     temperature: float = 0.7
     max_tokens: int = 2000
     api_key: Optional[str] = None
+    base_url: Optional[str] = None  # Custom endpoint (e.g., z.ai, local models)
 
 
 class LLMClient:
@@ -24,7 +25,10 @@ class LLMClient:
     def __init__(self, config: Optional[LLMConfig] = None):
         self.config = config or LLMConfig()
         try:
-            self.client = AsyncOpenAI(api_key=self.config.api_key)
+            client_kwargs = {"api_key": self.config.api_key}
+            if self.config.base_url:
+                client_kwargs["base_url"] = self.config.base_url
+            self.client = AsyncOpenAI(**client_kwargs)
         except Exception as e:
             if "api_key" in str(e).lower():
                 raise RuntimeError(
@@ -123,6 +127,17 @@ Focus on logical decomposition and clear dependencies. Keep tasks atomic and exe
                     "the request was filtered. Please try again or adjust your vibe."
                 )
 
+            # Strip markdown code blocks if present (common with some LLMs like z.ai/GLM)
+            content = content.strip()
+            if content.startswith("```"):
+                # Remove opening ```json or ``` 
+                first_newline = content.find("\n")
+                if first_newline != -1:
+                    content = content[first_newline + 1:]
+                # Remove closing ```
+                if content.endswith("```"):
+                    content = content[:-3].strip()
+
             return json.loads(content)
 
         except json.JSONDecodeError as e:

{vibe_aigc-0.2.0.dist-info → vibe_aigc-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibe-aigc
-Version: 0.2.0
+Version: 0.3.0
 Summary: A New Paradigm for Content Generation via Agentic Orchestration
 Author: Vibe AIGC Contributors
 License-Expression: MIT
@@ -19,6 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: openai>=1.0.0
 Provides-Extra: dev

{vibe_aigc-0.2.0.dist-info → vibe_aigc-0.3.0.dist-info}/RECORD

@@ -1,19 +1,20 @@
-vibe_aigc/__init__.py,sha256=jnKkqewzc-Rt2ylqZQkLbbWDyGK9fredSTs3pEA-vy4,2980
+vibe_aigc/__init__.py,sha256=xBc4OHS4gG7mRYLFI3M6AkJGviqNj-xzY11QhW6kFp8,3122
 vibe_aigc/agents.py,sha256=MAUQgJ4eygv3Uvri1xzF-WdExxyyPQvMWfXrW0AF9jE,21844
 vibe_aigc/assets.py,sha256=6CemoYHlssMpPn6lY13lw-98ZyUoKFqdNbqRagqZgUo,12462
 vibe_aigc/cli.py,sha256=7J62Bsa0FbbXrw5o5Cy7BpidAO99MOmKN_hlVjoSkhQ,7481
+vibe_aigc/comfyui.py,sha256=Do7kOaeiuJ0SVYsib2I5prOn5O0M_u0gPbK32cFHYg4,15663
 vibe_aigc/executor.py,sha256=AWTqa7hoDljhXjp6gCekzbTGROtD8kptb0IU3mi03lw,38977
-vibe_aigc/knowledge.py,sha256=KWfdh-xJFQTRfQjDGtvFiz9GsDudBpDC8nD75UuiosI,15604
-vibe_aigc/llm.py,sha256=JdItws0VbKS2qFIZE75yw-6bTyuyf4ERRq3kBEHRwDI,6117
+vibe_aigc/knowledge.py,sha256=UCh4AchG64T9mlXQcowYR2ywebic_ph3nvA7E-TdLPY,23820
+vibe_aigc/llm.py,sha256=ovRVKWGmcTmBTI5FI_MERK9ouxbEaO26-ArOaKTWqMY,6850
 vibe_aigc/models.py,sha256=wIwlN_NDL_72YXRq3Igi5X5fx1ZFGG7ER6pO5MdL4-I,2408
 vibe_aigc/persistence.py,sha256=inrJQjmCK4LighxQSmJorR6c7OvRzx-cmEb5HCQS9PY,10614
 vibe_aigc/planner.py,sha256=DRGIY7N7o4fl3ioa3azqSQf4eJwXCKgSoAg-lNaRq6U,26364
 vibe_aigc/tools.py,sha256=Tm_NA53yJjjvCrUuZ7YVtdLAdfUgxOLm5zZzIcJYvHI,15572
 vibe_aigc/tools_multimodal.py,sha256=asSJJqF0hrD9uNiYpuieVY-lbgEXjbK3UjT20nX2Lig,20405
 vibe_aigc/visualization.py,sha256=jDs2f1vj4k8ZnJTA_niKLBH2NMahTgWneiADlNmW24s,7143
-vibe_aigc-0.2.0.dist-info/licenses/LICENSE,sha256=Ir4dCTvOsbfoiOh9vYbhIKDH59S7J6qhJYZmHHICoKY,1079
-vibe_aigc-0.2.0.dist-info/METADATA,sha256=cSm1rxpFPJH96_4pXiETVVArK7ggf-konV0wGsES9-I,6573
-vibe_aigc-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-vibe_aigc-0.2.0.dist-info/entry_points.txt,sha256=2htp4yXJMvCAQXTB39XWWwbBPP3MYUYXsqlwMeQsd7o,49
-vibe_aigc-0.2.0.dist-info/top_level.txt,sha256=Cpjz8X0WEhnhaigqxmsZSl9VxduaDspj7WuVUGGLeao,10
-vibe_aigc-0.2.0.dist-info/RECORD,,
+vibe_aigc-0.3.0.dist-info/licenses/LICENSE,sha256=Ir4dCTvOsbfoiOh9vYbhIKDH59S7J6qhJYZmHHICoKY,1079
+vibe_aigc-0.3.0.dist-info/METADATA,sha256=Gjoxon64TochZCxr82gVUo4U294LyzZZ3HLd31ew5_M,6604
+vibe_aigc-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+vibe_aigc-0.3.0.dist-info/entry_points.txt,sha256=2htp4yXJMvCAQXTB39XWWwbBPP3MYUYXsqlwMeQsd7o,49
+vibe_aigc-0.3.0.dist-info/top_level.txt,sha256=Cpjz8X0WEhnhaigqxmsZSl9VxduaDspj7WuVUGGLeao,10
+vibe_aigc-0.3.0.dist-info/RECORD,,