@_vrsen/openswarm 0.1.0

package/image_generation_agent/tools/utils/image_io.py

@@ -0,0 +1,308 @@
+import base64
+import concurrent.futures
+import io
+import os
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import requests
+from PIL import Image
+
+from agency_swarm import ToolOutputImage, ToolOutputText
+
+
+DEFAULT_EXTENSIONS = (".png", ".jpg", ".jpeg", ".webp")
+ALL_ASPECT_RATIOS = (
+    "1:1",
+    "2:3",
+    "3:2",
+    "3:4",
+    "4:3",
+    "4:5",
+    "5:4",
+    "9:16",
+    "16:9",
+    "21:9",
+)
+SUPPORTED_ASPECT_RATIOS_BY_MODEL = {
+    "gemini-2.5-flash-image": set(ALL_ASPECT_RATIOS),
+    "gemini-3-pro-image-preview": set(ALL_ASPECT_RATIOS),
+    # OpenAI image API size options are:
+    # 1024x1024 (1:1), 1024x1536 (2:3), 1536x1024 (3:2)
+    "gpt-image-1.5": {"1:1", "2:3", "3:2"},
+}
+OPENAI_SIZE_BY_ASPECT_RATIO = {
+    "1:1": "1024x1024",
+    "2:3": "1024x1536",
+    "3:2": "1536x1024",
+}
+
+if os.path.isfile("/.dockerenv"):
+    MNT_DIR = Path("/app/mnt")
+else:
+    MNT_DIR = Path(__file__).parent.parent.parent.parent / "mnt"
+
+
+def get_images_dir(product_name: str) -> Path:
+    images_dir = MNT_DIR / product_name / "generated_images"
+    images_dir.mkdir(parents=True, exist_ok=True)
+    return images_dir
+
+
+def find_image_path_from_name(images_dir: Path, image_name: str) -> Path | None:
+    for ext in DEFAULT_EXTENSIONS:
+        candidate = images_dir / f"{image_name}{ext}"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def resolve_image_reference(product_name: str, image_ref: str) -> tuple[Image.Image, str]:
+    if not image_ref.strip():
+        raise ValueError("image reference must not be empty")
+
+    parsed = urlparse(image_ref)
+    if parsed.scheme in ("http", "https"):
+        response = requests.get(image_ref, timeout=30)
+        response.raise_for_status()
+        image = Image.open(io.BytesIO(response.content))
+        return image.convert("RGB"), image_ref
+
+    candidate_path = Path(image_ref).expanduser().resolve()
+    if candidate_path.exists():
+        image = Image.open(candidate_path)
+        return image.convert("RGB"), str(candidate_path)
+
+    images_dir = get_images_dir(product_name)
+    by_name = find_image_path_from_name(images_dir, image_ref)
+    if by_name is not None:
+        image = Image.open(by_name)
+        return image.convert("RGB"), str(by_name)
+
+    raise FileNotFoundError(
+        f"Could not resolve image reference '{image_ref}' as URL, path, or name in {images_dir}."
+    )
+
+
+_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tiff"}
+
+
+def normalize_file_name(value: str) -> str:
+    """Strip a known image extension from the name, but leave other dots untouched.
+
+    "hero.png"   → "hero"
+    "5.1_no_bg"  → "5.1_no_bg"  (dot is part of the name, not an extension)
+    """
+    name = value.strip()
+    if not name:
+        raise ValueError("file name must not be empty")
+    p = Path(name)
+    return p.stem if p.suffix.lower() in _IMAGE_EXTENSIONS else name
+
+
+def build_variant_output_name(output_name: str, variant_index: int, total_variants: int) -> str:
+    raw_value = output_name.strip()
+    if not raw_value:
+        raise ValueError("output name must not be empty")
+    if total_variants <= 1:
+        return raw_value
+
+    candidate = Path(raw_value)
+    has_image_ext = candidate.suffix.lower() in _IMAGE_EXTENSIONS
+    if has_image_ext:
+        variant_file = f"{candidate.stem}_variant_{variant_index}{candidate.suffix}"
+        return str(candidate.with_name(variant_file))
+
+    return f"{raw_value}_variant_{variant_index}"
+
+
+def save_image(image: Image.Image, output_name: str, images_dir: Path) -> tuple[str, str]:
+    raw_value = output_name.strip()
+    candidate = Path(raw_value).expanduser()
+
+    has_image_ext = candidate.suffix.lower() in _IMAGE_EXTENSIONS
+    has_path_sep = any(sep in raw_value for sep in ("/", "\\"))
+
+    if has_image_ext:
+        output_path = candidate if candidate.is_absolute() else images_dir / candidate
+        image_name = output_path.stem
+    elif has_path_sep:
+        output_path = candidate if candidate.is_absolute() else images_dir / candidate
+        output_path = output_path.with_suffix(".png")
+        image_name = output_path.stem
+    else:
+        image_name = normalize_file_name(raw_value)
+        output_path = images_dir / f"{image_name}.png"
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    image.save(output_path, format="PNG")
+    return image_name, str(output_path)
+
+
+def image_to_base64_jpeg(
+    image: Image.Image,
+    max_size: int = 768,
+    target_bytes: int = 120_000,
+    min_quality: int = 45,
+) -> str:
+    """
+    Create a compact JPEG preview for multimodal outputs.
+
+    This intentionally optimizes for small payload size to reduce token costs.
+    """
+    rgb = image.convert("RGB")
+    width, height = rgb.size
+
+    if max(width, height) > max_size:
+        scale = max_size / max(width, height)
+        rgb = rgb.resize((int(width * scale), int(height * scale)), Image.Resampling.LANCZOS)
+
+    best_bytes: bytes | None = None
+    work = rgb
+    quality_steps = (80, 70, 62, 55, min_quality)
+
+    # Try lowering JPEG quality first.
+    for quality in quality_steps:
+        buffer = io.BytesIO()
+        work.save(buffer, format="JPEG", quality=quality, optimize=True, progressive=True)
+        candidate = buffer.getvalue()
+        if best_bytes is None or len(candidate) < len(best_bytes):
+            best_bytes = candidate
+        if len(candidate) <= target_bytes:
+            return base64.b64encode(candidate).decode("utf-8")
+
+    # If still too large, iteratively downscale and retry quality steps.
+    while max(work.size) > 320:
+        next_size = (max(1, int(work.width * 0.85)), max(1, int(work.height * 0.85)))
+        work = work.resize(next_size, Image.Resampling.LANCZOS)
+        for quality in quality_steps:
+            buffer = io.BytesIO()
+            work.save(buffer, format="JPEG", quality=quality, optimize=True, progressive=True)
+            candidate = buffer.getvalue()
+            if best_bytes is None or len(candidate) < len(best_bytes):
+                best_bytes = candidate
+            if len(candidate) <= target_bytes:
+                return base64.b64encode(candidate).decode("utf-8")
+
+    # Final fallback: return the smallest candidate we produced.
+    assert best_bytes is not None
+    return base64.b64encode(best_bytes).decode("utf-8")
+
+
+def build_multimodal_outputs(items: list[dict[str, Any]], title: str) -> list:
+    lines = [f"{title}: {len(items)} image(s)"]
+    for item in items:
+        lines.append(f"- {item['image_name']}: {item['file_path']}")
+
+    outputs: list = [ToolOutputText(type="text", text="\n".join(lines))]
+    for item in items:
+        outputs.append(ToolOutputText(type="text", text=f"Path: {item['file_path']}"))
+        outputs.append(
+            ToolOutputImage(
+                type="image",
+                image_url=f"data:image/jpeg;base64,{item['preview_b64']}",
+                detail="auto",
+            )
+        )
+    return outputs
+
+
+def extract_gemini_image_and_usage(response: Any) -> tuple[Image.Image | None, dict]:
+    image: Image.Image | None = None
+    usage = getattr(response, "usage_metadata", {}) or {}
+
+    if usage and not isinstance(usage, dict):
+        if hasattr(usage, "model_dump"):
+            usage = usage.model_dump()
+        elif hasattr(usage, "__dict__"):
+            usage = vars(usage)
+        else:
+            try:
+                usage = dict(usage)
+            except (TypeError, ValueError):
+                usage = {}
+
+    candidates = getattr(response, "candidates", None) or []
+    for candidate in candidates:
+        content = getattr(candidate, "content", None)
+        parts = getattr(content, "parts", None) or []
+        for part in parts:
+            inline_data = getattr(part, "inline_data", None)
+            if inline_data and getattr(inline_data, "data", None):
+                image = Image.open(io.BytesIO(inline_data.data)).convert("RGB")
+                return image, usage
+
+    parts = getattr(response, "parts", None) or []
+    for part in parts:
+        inline_data = getattr(part, "inline_data", None)
+        if inline_data and getattr(inline_data, "data", None):
+            image = Image.open(io.BytesIO(inline_data.data)).convert("RGB")
+            return image, usage
+
+    return None, usage
+
+
+def extract_openai_images_and_usage(response: Any) -> tuple[list[Image.Image], dict]:
+    usage = getattr(response, "usage", {}) or {}
+    if usage and not isinstance(usage, dict):
+        if hasattr(usage, "model_dump"):
+            usage = usage.model_dump()
+        elif hasattr(usage, "__dict__"):
+            usage = vars(usage)
+        else:
+            try:
+                usage = dict(usage)
+            except (TypeError, ValueError):
+                usage = {}
+
+    images: list[Image.Image] = []
+    data = getattr(response, "data", None) or []
+    for item in data:
+        b64 = getattr(item, "b64_json", None)
+        if b64:
+            raw = base64.b64decode(b64)
+            images.append(Image.open(io.BytesIO(raw)).convert("RGB"))
+
+    return images, usage
+
+
+def run_parallel_variants_sync(task_fn, num_variants: int) -> list:
+    results_by_index: dict[int, Any] = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=num_variants) as executor:
+        future_to_index = {
+            executor.submit(task_fn, idx): idx
+            for idx in range(1, num_variants + 1)
+        }
+        for future in concurrent.futures.as_completed(future_to_index):
+            idx = future_to_index[future]
+            try:
+                result = future.result()
+                if result is not None:
+                    results_by_index[idx] = result
+            except Exception:
+                pass
+
+    return [results_by_index[idx] for idx in sorted(results_by_index.keys())]
+
+
+def validate_aspect_ratio_for_model(model: str, aspect_ratio: str) -> None:
+    supported = SUPPORTED_ASPECT_RATIOS_BY_MODEL.get(model)
+    if supported is None:
+        raise ValueError(f"Unsupported model: {model}")
+    if aspect_ratio not in supported:
+        raise ValueError(
+            f"Aspect ratio '{aspect_ratio}' is not supported by model '{model}'. "
+            f"Supported values: {sorted(supported)}"
+        )
+
+
+def get_openai_size_for_aspect_ratio(aspect_ratio: str) -> str:
+    size = OPENAI_SIZE_BY_ASPECT_RATIO.get(aspect_ratio)
+    if not size:
+        raise ValueError(
+            f"Aspect ratio '{aspect_ratio}' cannot be mapped to an OpenAI image size. "
+            f"Supported values: {sorted(OPENAI_SIZE_BY_ASPECT_RATIO.keys())}"
+        )
+    return size
+

package/onboard.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""OpenSwarm interactive setup wizard.
+
+Run directly:   python onboard.py
+Auto-launched:  python run.py  (when no provider key is found)
+"""
+
+import getpass
+import sys
+from pathlib import Path
+
+from dotenv import dotenv_values, set_key
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.table import Table
+
+try:
+    import questionary
+    from questionary import Choice, Style as QStyle
+    import questionary.prompts.common as _qc_common
+
+    # Swap filled circle → checkmark for selected state.
+    _qc_common.INDICATOR_SELECTED = "✓"
+
+    _HAS_QUESTIONARY = True
+except ImportError:
+    _HAS_QUESTIONARY = False
+
+console = Console()
+
+ENV_PATH = Path(__file__).parent / ".env"
+
+# ── questionary theme ─────────────────────────────────────────────────────────
+_QSTYLE = None
+if _HAS_QUESTIONARY:
+    _QSTYLE = QStyle([
+        ("qmark",       "fg:#4fc3f7 bold"),
+        ("question",    "bold"),
+        ("answer",      "fg:#4fc3f7 bold"),
+        ("pointer",     "fg:#4fc3f7 bold noreverse"),
+        ("highlighted", "noreverse"),
+        ("selected",    "fg:#4fc3f7 bold noreverse"),
+        ("separator",   "fg:#555555 noreverse"),
+        ("instruction", "fg:#555555 italic noreverse"),
+        ("text",        "noreverse"),
+    ])
+
+# ── provider definitions ──────────────────────────────────────────────────────
+PROVIDERS = [
+    {
+        "name":         "OpenAI",
+        "env_key":      "OPENAI_API_KEY",
+        "default_model": "gpt-5.2",
+        "url":          "https://platform.openai.com/api-keys",
+    },
+    {
+        "name":         "Anthropic",
+        "env_key":      "ANTHROPIC_API_KEY",
+        "default_model": "litellm/claude-sonnet-4-6",
+        "url":          "https://console.anthropic.com/settings/keys",
+    },
+    {
+        "name":         "Google Gemini",
+        "env_key":      "GOOGLE_API_KEY",
+        "default_model": "litellm/gemini/gemini-3-flash",
+        "url":          "https://aistudio.google.com/app/apikey",
+    },
+]
+
+# ── add-on definitions ────────────────────────────────────────────────────────
+# exclude_for: list of provider names that already cover this key
+ADD_ONS = [
+    {
+        "id":          "search",
+        "name":        "Web Search",
+        "description": "Web, Scholar & product search for all agents",
+        "keys": [
+            {"env": "SEARCH_API_KEY", "label": "SearchAPI key",
+             "url": "https://www.searchapi.io"},
+        ],
+        "exclude_for": [],
+    },
+    {
+        "id":          "anthropic",
+        "name":        "Anthropic Claude  —  better slides quality",
+        "description": "Claude produces significantly better slide HTML output",
+        "keys": [
+            {"env": "ANTHROPIC_API_KEY", "label": "Anthropic API key",
+             "url": "https://console.anthropic.com/settings/keys"},
+        ],
+        "exclude_for": ["Anthropic"],
+    },
+    {
+        "id":          "composio",
+        "name":        "Composio  —  10,000+ integrations",
+        "description": "Gmail, Slack, GitHub, HubSpot, Google Calendar and more",
+        "keys": [
+            {"env": "COMPOSIO_API_KEY", "label": "Composio API key",
+             "url": "https://composio.dev"},
+            {"env": "COMPOSIO_USER_ID", "label": "Composio user ID",
+             "url": "https://composio.dev"},
+        ],
+        "exclude_for": [],
+    },
+    {
+        "id":          "google",
+        "name":        "Google Gemini  —  image gen & Veo video",
+        "description": "Gemini image generation/editing and Veo video generation",
+        "keys": [
+            {"env": "GOOGLE_API_KEY", "label": "Google AI API key",
+             "url": "https://aistudio.google.com/app/apikey"},
+        ],
+        "exclude_for": ["Google Gemini"],
+    },
+    {
+        "id":          "fal",
+        "name":        "Fal.ai  —  Seedance video & background removal",
+        "description": "Seedance 1.5 Pro video gen, video editing, background removal",
+        "keys": [
+            {"env": "FAL_KEY", "label": "Fal.ai API key",
+             "url": "https://fal.ai/dashboard/keys"},
+        ],
+        "exclude_for": [],
+    },
+    {
+        "id":          "stock",
+        "name":        "Stock photos  —  Pexels / Pixabay / Unsplash",
+        "description": "Image search for the Slides Agent",
+        "keys": [
+            {"env": "PEXELS_API_KEY",     "label": "Pexels API key",
+             "url": "https://www.pexels.com/api"},
+            {"env": "PIXABAY_API_KEY",    "label": "Pixabay API key",
+             "url": "https://pixabay.com/api/docs"},
+            {"env": "UNSPLASH_ACCESS_KEY", "label": "Unsplash access key",
+             "url": "https://unsplash.com/developers"},
+        ],
+        "exclude_for": [],
+    },
+]
+
+# ── ui helpers ────────────────────────────────────────────────────────────────
+
+def _step(n: int, label: str) -> None:
+    console.print()
+    console.print(Rule(f"[bold]Step {n}  ·  {label}[/bold]", style="cyan"))
+    console.print()
+
+
+def _ask_select(message: str, choices: list) -> object:
+    if _HAS_QUESTIONARY:
+        return questionary.select(message, choices=choices, style=_QSTYLE).ask()
+    # plain fallback
+    titles = [c.title if isinstance(c, Choice) else c for c in choices]
+    values = [c.value if isinstance(c, Choice) else c for c in choices]
+    console.print(f"\n[bold]{message}[/bold]")
+    for i, title in enumerate(titles, 1):
+        console.print(f"  [cyan]{i}.[/cyan] {title}")
+    while True:
+        raw = input("Enter number: ").strip()
+        if raw.isdigit() and 1 <= int(raw) <= len(titles):
+            return values[int(raw) - 1]
+        console.print("[red]Invalid choice, try again.[/red]")
+
+
+def _ask_checkbox(message: str, choices: list) -> list:
+    if _HAS_QUESTIONARY:
+        return questionary.checkbox(message, choices=choices, style=_QSTYLE, pointer="❯").ask() or []
+    # plain fallback — comma-separated numbers
+    titles = [c.title if isinstance(c, Choice) else c for c in choices]
+    values = [c.value if isinstance(c, Choice) else c for c in choices]
+    console.print(f"\n[bold]{message}[/bold]")
+    console.print("[dim]  Enter comma-separated numbers, or press Enter to skip[/dim]")
+    for i, title in enumerate(titles, 1):
+        console.print(f"  [cyan]{i}.[/cyan] {title}")
+    raw = input("Selection: ").strip()
+    if not raw:
+        return []
+    result = []
+    for part in raw.split(","):
+        part = part.strip()
+        if part.isdigit() and 1 <= int(part) <= len(titles):
+            result.append(values[int(part) - 1])
+    return result
+
+
+def _ask_secret(label: str, url: str) -> str:
+    console.print(f"  [dim]Get yours at[/dim] [link={url}]{url}[/link]")
+    if _HAS_QUESTIONARY:
+        val = questionary.password(f"  {label}: ", style=_QSTYLE).ask()
+        return (val or "").strip()
+    return getpass.getpass(f"  {label}: ").strip()
+
+
+def _ask_confirm(message: str, default: bool = True) -> bool:
+    if _HAS_QUESTIONARY:
+        return questionary.confirm(message, default=default, style=_QSTYLE).ask()
+    prompt = f"{message} [{'Y/n' if default else 'y/N'}]: "
+    raw = input(prompt).strip().lower()
+    return default if not raw else raw in ("y", "yes")
+
+
+def _write_env(updates: dict) -> None:
+    if not ENV_PATH.exists():
+        ENV_PATH.write_text("", encoding="utf-8")
+    for key, value in updates.items():
+        if value:
+            set_key(str(ENV_PATH), key, value)
+
+
+# ── main wizard ───────────────────────────────────────────────────────────────
+
+def run_onboarding() -> None:
+    console.print()
+    console.print(Panel.fit(
+        "[bold cyan]OpenSwarm[/bold cyan]  [dim]—  open-source multi-agent AI team[/dim]\n"
+        "[dim]Let's get you set up in a few steps.[/dim]",
+        border_style="cyan",
+        padding=(1, 4),
+    ))
+
+    existing = dotenv_values(str(ENV_PATH)) if ENV_PATH.exists() else {}
+    updates: dict[str, str] = {}
+
+    # ── Step 1: provider ──────────────────────────────────────────────────────
+    _step(1, "AI Provider")
+
+    provider_choices = [
+        Choice(title=p["name"], value=p)
+        for p in PROVIDERS
+    ]
+    provider = _ask_select("Choose your primary AI provider:", provider_choices)
+
+    # ── Step 2: API key ───────────────────────────────────────────────────────
+    _step(2, "API Key")
+
+    existing_key = existing.get(provider["env_key"], "")
+    if existing_key:
+        console.print(f"  [dim]{provider['env_key']} is already configured.[/dim]")
+        if _ask_confirm("  Update it?", default=False):
+            key = _ask_secret(f"{provider['name']} API key", provider["url"])
+            updates[provider["env_key"]] = key or existing_key
+        else:
+            updates[provider["env_key"]] = existing_key
+    else:
+        key = _ask_secret(f"{provider['name']} API key", provider["url"])
+        if key:
+            updates[provider["env_key"]] = key
+
+    updates["DEFAULT_MODEL"]       = provider["default_model"]
+
+    # ── Step 3: add-ons ───────────────────────────────────────────────────────
+    _step(3, "Add-ons  [dim](optional)[/dim]")
+
+    available = [a for a in ADD_ONS if provider["name"] not in a["exclude_for"]]
+    addon_choices = [
+        Choice(
+            title=(
+                [
+                    ("class:text",  a["name"]),
+                    ("fg:#555555",  "  ·  "),
+                    ("fg:#666666",  a["description"]),
+                ]
+                if _HAS_QUESTIONARY
+                else f"{a['name']}  —  {a['description']}"
+            ),
+            value=a["id"],
+        )
+        for a in available
+    ]
+    selected_ids = _ask_checkbox("Select add-ons to enable:", addon_choices)
+    selected_addons = [a for a in available if a["id"] in selected_ids]
+
+    # ── Step 4: add-on keys ───────────────────────────────────────────────────
+    if selected_addons:
+        _step(4, "Add-on Keys")
+        for addon in selected_addons:
+            console.print(f"\n  [bold]{addon['name'].split('  ')[0]}[/bold]")
+            for key_spec in addon["keys"]:
+                existing_val = existing.get(key_spec["env"], "")
+                if existing_val:
+                    console.print(f"  [dim]{key_spec['env']} is already configured.[/dim]")
+                    if not _ask_confirm("  Update it?", default=False):
+                        updates[key_spec["env"]] = existing_val
+                        continue
+                val = _ask_secret(key_spec["label"], key_spec["url"])
+                if val:
+                    updates[key_spec["env"]] = val
+
+    # ── write .env ────────────────────────────────────────────────────────────
+    _write_env(updates)
+
+    # ── summary ───────────────────────────────────────────────────────────────
+    console.print()
+    console.print(Rule("[bold green]Setup complete[/bold green]", style="green"))
+    console.print()
+
+    table = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+    table.add_column(style="dim", no_wrap=True)
+    table.add_column()
+    table.add_row("Provider", f"[cyan]{provider['name']}[/cyan]")
+    table.add_row("Model",    f"[cyan]{provider['default_model']}[/cyan]")
+    table.add_row(".env",     f"[cyan]{ENV_PATH}[/cyan]")
+    saved = [k for k, v in updates.items() if v and not k.startswith("DEFAULT_")]
+    if saved:
+        table.add_row("Keys saved", f"[cyan]{', '.join(saved)}[/cyan]")
+    console.print(table)
+
+    console.print()
+    console.print(Panel(
+        "[bold]python swarm.py[/bold]  [dim]launch interactive terminal[/dim]\n"
+        "[bold]python server.py[/bold]  [dim]start the API server[/dim]",
+        border_style="green",
+        padding=(0, 3),
+    ))
+    console.print()
+
+
+if __name__ == "__main__":
+    try:
+        run_onboarding()
+    except KeyboardInterrupt:
+        console.print("\n\n[dim]Setup cancelled.[/dim]\n")
+        sys.exit(0)

package/orchestrator/__init__.py

@@ -0,0 +1,3 @@
+from .orchestrator import create_orchestrator
+
+__all__ = ["create_orchestrator"]