@1mancompany/onemancompany 0.7.68 → 0.7.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mancompany/onemancompany",
-  "version": "0.7.68",
+  "version": "0.7.70",
   "description": "The AI Operating System for One-Person Companies",
   "bin": {
     "onemancompany": "bin/cli.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onemancompany"
-version = "0.7.68"
+version = "0.7.70"
 description = "A one-man company simulation with pixel art visualization and LangChain AI agents"
 requires-python = ">=3.12"
 dependencies = [

package/src/onemancompany/agents/base.py

@@ -221,6 +221,11 @@ def make_llm(employee_id: str = "", temperature: float | None = None) -> BaseCha
                 base_url = settings.openrouter_base_url
             elif api_provider == "custom" or (settings.default_api_base_url and api_provider == settings.default_api_provider):
                 base_url = settings.default_api_base_url
+            extra_body = None
+            if (api_provider or "").lower() == "deepseek":
+                # DeepSeek V4 thinking mode currently requires reasoning_content
+                # replay across tool calls, which LangChain does not preserve.
+                extra_body = {"thinking": {"type": "disabled"}}
             return ChatOpenAI(
                 model=model,
                 api_key=effective_key,
@@ -229,6 +234,7 @@ def make_llm(employee_id: str = "", temperature: float | None = None) -> BaseCha
                 max_retries=3,
                 request_timeout=300.0,
                 stream_usage=True,
+                extra_body=extra_body,
             )
 
     # --- Fallback: unknown provider or no key → fall back to openrouter with default model ---

package/src/onemancompany/core/default_vessel.yaml

@@ -20,4 +20,3 @@ capabilities:
   file_upload: false
   websocket: false
   sandbox: false
-  image_generation: false

package/src/onemancompany/core/standalone_runner.py

@@ -96,7 +96,18 @@ def _load_llm(profile: dict):
         base_url = prov[0]
         if provider_name == "openrouter":
             base_url = os.environ.get("OPENROUTER_BASE_URL", base_url)
-        return ChatOpenAI(model=model, api_key=key, base_url=base_url, temperature=temperature)
+        extra_body = None
+        if (provider_name or "").lower() == "deepseek":
+            # DeepSeek V4 thinking mode requires reasoning_content replay
+            # across tool calls; LangChain does not preserve it yet.
+            extra_body = {{"thinking": {{"type": "disabled"}}}}
+        return ChatOpenAI(
+            model=model,
+            api_key=key,
+            base_url=base_url,
+            temperature=temperature,
+            extra_body=extra_body,
+        )
 
     # Unknown provider — fall back to OpenRouter
     key = api_key or os.environ.get("OPENROUTER_API_KEY", "")

package/src/onemancompany/core/vessel_config.py

@@ -72,7 +72,6 @@ class CapabilitiesConfig:
     file_upload: bool = False
     websocket: bool = False
     sandbox: bool = False
-    image_generation: bool = False
 
 
 @dataclass
@@ -138,7 +137,6 @@ def _parse_vessel_dict(raw: dict) -> VesselConfig:
             file_upload=caps_raw.get("file_upload", False),
             websocket=caps_raw.get("websocket", False),
             sandbox=caps_raw.get("sandbox", False),
-            image_generation=caps_raw.get("image_generation", False),
         ),
     )
 
@@ -207,11 +205,9 @@ def save_vessel_config(emp_dir: Path, config: VesselConfig) -> None:
             "file_upload": config.capabilities.file_upload,
             "websocket": config.capabilities.websocket,
             "sandbox": config.capabilities.sandbox,
-            "image_generation": config.capabilities.image_generation,
         },
     }
 
     with open_utf(vessel_dir / VESSEL_YAML_FILENAME, "w") as f:
         yaml.dump(data, f, default_flow_style=False, allow_unicode=True)
 
-

package/src/onemancompany/onboard.py

@@ -83,7 +83,7 @@ LOGO = r"""
  ░▒▓  [ NEURAL BOOTSTRAP SEQUENCE ]
 """
 
-TOTAL_STEPS = 6
+TOTAL_STEPS = 5
 
 HOSTING_LABELS = {"company": "LangChain", "self": "Claude Code", "openclaw": "OpenClaw"}
 
@@ -418,7 +418,7 @@ def _step_llm(console: Console) -> tuple[str, str, str, str]:
 
 def _step_server(console: Console) -> tuple[str, int]:
     console.print()
-    _print_step(console, 5, "NETWORK NODE", "Server Configuration")
+    _print_step(console, 4, "NETWORK NODE", "Server Configuration")
     console.print(
         "\n  [dim]Deploy your company node on the local network.[/dim]\n"
         "  [dim]After genesis, open the URL to enter your office.[/dim]\n"
@@ -544,64 +544,6 @@ def _step_agent_family(console: Console) -> dict[str, str]:
     return founders
 
 
-def _step_sandbox(console: Console) -> bool:
-    """Ask whether to install sandbox tools (Docker-based code execution)."""
-    console.print()
-    _print_step(console, 4, "SANDBOX MESH", "Isolated Execution")
-    console.print(
-        "\n  [dim]Sandbox gives your AI employees a safe place to run code.\n"
-        "  Without it, code execution happens directly on your machine.\n"
-        "  With it, each task runs in an isolated Docker container.[/dim]\n"
-    )
-    console.print(
-        "  [bold]Requirements:[/bold]\n"
-        "    • [cyan]Docker[/cyan] — must be installed and running\n"
-        "    • Python packages will be installed automatically\n"
-        "  [dim]This is optional. You can always enable it later.[/dim]\n"
-    )
-    from InquirerPy import inquirer as _inq
-    install = _inq.confirm(
-        message="Install sandbox tools?",
-        default=False,
-        style=INQ_STYLE,
-    ).execute()
-    if install:
-        console.print()
-        _install_sandbox_deps(console)
-    return install
-
-
-def _install_sandbox_deps(console: Console) -> None:
-    """Attempt to install sandbox optional dependencies via uv/pip."""
-    import subprocess
-    import sys
-
-    # Try uv first, fall back to pip
-    venv_python = sys.executable
-    cmds = [
-        [venv_python, "-m", "uv", "pip", "install", "onemancompany[sandbox]"],
-        [venv_python, "-m", "pip", "install", "onemancompany[sandbox]"],
-    ]
-    for cmd in cmds:
-        try:
-            with console.status("  Installing sandbox dependencies..."):
-                result = subprocess.run(
-                    cmd, capture_output=True, text=True, timeout=120,
-                )
-            if result.returncode == 0:
-                console.print("  [green]✔[/green] Sandbox dependencies installed")
-                return
-        except FileNotFoundError:
-            console.print(f"  [dim]{cmd[2]} not available, trying fallback...[/dim]")
-        except subprocess.TimeoutExpired:
-            console.print("  [yellow]⚠[/yellow] Installation timed out")
-
-    console.print(
-        "  [yellow]⚠[/yellow] Auto-install failed. Install manually:\n"
-        "    [dim]uv pip install 'onemancompany[sandbox]'[/dim]"
-    )
-
-
 def _step_optional(console: Console) -> dict[str, str]:
     console.print()
     _print_step(console, 3, "UPLINK ARRAY", "External Integrations")
@@ -694,7 +636,7 @@ def _step_execute(
     custom_chat_class: str = "",
 ) -> None:
     console.print()
-    _print_step(console, 6, "GENESIS", "Company Initialization")
+    _print_step(console, 5, "GENESIS", "Company Initialization")
     console.print(
         "\n  [dim]Deploying company infrastructure and founding team...[/dim]\n"
     )
@@ -1010,10 +952,9 @@ def run_wizard() -> None:
     founder_families = _step_agent_family(console)      # Step 1: Agent Family
     provider, api_key, model, base_url, custom_chat_class = _step_llm(console)  # Step 2: LLM Provider & Key
     extras = _step_optional(console)                     # Step 3: External Integrations
-    sandbox_enabled = _step_sandbox(console)             # Step 4: Sandbox
-    host, port = _step_server(console)                   # Step 5: Server
+    host, port = _step_server(console)                   # Step 4: Server
     _step_execute(console, provider, api_key, model, host, port, extras,
-                  sandbox_enabled=sandbox_enabled, founder_families=founder_families,
+                  founder_families=founder_families,
                   base_url=base_url, custom_chat_class=custom_chat_class)
     _step_done(console, host, port)
 

package/company/assets/tools/background_removal/background_removal.py

@@ -1,158 +0,0 @@
-"""Background removal tool for generated images.
-
-Provides one LangChain @tool:
-- remove_image_background(input_path, output_path, tolerance=28)
-"""
-
-from __future__ import annotations
-
-from collections import deque
-from pathlib import Path
-
-from langchain_core.tools import tool
-
-
-def _dominant_corner_color(px, width: int, height: int) -> tuple[int, int, int]:
-    """Estimate background color from the most similar corner cluster."""
-    corners = [
-        px[0, 0][:3],
-        px[max(width - 1, 0), 0][:3],
-        px[0, max(height - 1, 0)][:3],
-        px[max(width - 1, 0), max(height - 1, 0)][:3],
-    ]
-    # 16-level quantization keeps similar corner colors in one bucket.
-    buckets: dict[tuple[int, int, int], list[tuple[int, int, int]]] = {}
-    for c in corners:
-        key = (c[0] // 16, c[1] // 16, c[2] // 16)
-        buckets.setdefault(key, []).append(c)
-    dominant = max(buckets.values(), key=len)
-    r = sum(c[0] for c in dominant) // len(dominant)
-    g = sum(c[1] for c in dominant) // len(dominant)
-    b = sum(c[2] for c in dominant) // len(dominant)
-    return r, g, b
-
-
-def _is_close_to_bg(rgb: tuple[int, int, int], bg: tuple[int, int, int], tolerance: int) -> bool:
-    """Fast color similarity check (Manhattan distance)."""
-    return (
-        abs(rgb[0] - bg[0]) +
-        abs(rgb[1] - bg[1]) +
-        abs(rgb[2] - bg[2])
-    ) <= tolerance * 3
-
-
-@tool
-def remove_image_background(input_path: str, output_path: str, tolerance: int = 28) -> dict:
-    """Remove background from an image and save as transparent PNG. USE THIS after image_generation when transparency is needed.
-
-    Best for: logos, stickers, product images, overlays — any image that needs a transparent background.
-
-    Args:
-        input_path: Source image path (output from image_generation).
-        output_path: Output path (will be saved as .png with transparency).
-        tolerance: Color tolerance for background matching (0-255, default 28). Increase for noisy backgrounds.
-    """
-    input_path = (input_path or "").strip()
-    output_path = (output_path or "").strip()
-    if not input_path:
-        return {"status": "error", "message": "input_path is empty"}
-    if not output_path:
-        return {"status": "error", "message": "output_path is empty"}
-
-    tolerance = max(0, min(int(tolerance), 255))
-
-    src = Path(input_path).expanduser()
-    if not src.exists() or not src.is_file():
-        return {"status": "error", "message": f"input file not found: {src}"}
-
-    try:
-        from PIL import Image
-    except ImportError:
-        return {"status": "error", "message": "Pillow is required (pip install pillow)"}
-
-    try:
-        img = Image.open(src).convert("RGBA")
-    except Exception as e:
-        return {"status": "error", "message": f"failed to read image: {e}"}
-
-    width, height = img.size
-    if width == 0 or height == 0:
-        return {"status": "error", "message": "invalid image size"}
-
-    px = img.load()
-    bg_color = _dominant_corner_color(px, width, height)
-    visited = bytearray(width * height)
-    q: deque[tuple[int, int]] = deque()
-
-    def idx(x: int, y: int) -> int:
-        return y * width + x
-
-    def maybe_enqueue(x: int, y: int) -> None:
-        if x < 0 or y < 0 or x >= width or y >= height:
-            return
-        p = px[x, y]
-        rgb = p[:3]
-        if p[3] == 0 or _is_close_to_bg(rgb, bg_color, tolerance):
-            q.append((x, y))
-
-    # Seed flood fill from image borders only, so subject interior isn't removed.
-    for x in range(width):
-        maybe_enqueue(x, 0)
-        if height > 1:
-            maybe_enqueue(x, height - 1)
-    for y in range(1, height - 1):
-        maybe_enqueue(0, y)
-        if width > 1:
-            maybe_enqueue(width - 1, y)
-
-    while q:
-        x, y = q.popleft()
-        if x < 0 or y < 0 or x >= width or y >= height:
-            continue
-        i = idx(x, y)
-        if visited[i]:
-            continue
-
-        p = px[x, y]
-        rgb = p[:3]
-        if p[3] != 0 and not _is_close_to_bg(rgb, bg_color, tolerance):
-            continue
-
-        visited[i] = 1
-        q.append((x + 1, y))
-        q.append((x - 1, y))
-        q.append((x, y + 1))
-        q.append((x, y - 1))
-
-    removed_pixels = 0
-    for y in range(height):
-        for x in range(width):
-            i = idx(x, y)
-            if not visited[i]:
-                continue
-            r, g, b, a = px[x, y]
-            if a != 0:
-                px[x, y] = (r, g, b, 0)
-                removed_pixels += 1
-
-    out = Path(output_path).expanduser()
-    if out.suffix.lower() != ".png":
-        out = out.with_suffix(".png")
-    out.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        img.save(out, format="PNG")
-    except Exception as e:
-        return {"status": "error", "message": f"failed to save output: {e}"}
-
-    total_pixels = width * height
-    return {
-        "status": "ok",
-        "input_path": str(src),
-        "output_path": str(out),
-        "size": {"width": width, "height": height},
-        "bg_color_rgb": bg_color,
-        "tolerance": tolerance,
-        "removed_pixels": removed_pixels,
-        "removed_ratio": round(removed_pixels / max(total_pixels, 1), 4),
-    }

package/company/assets/tools/background_removal/tool.yaml

@@ -1,9 +0,0 @@
-id: background_removal
-name: Background Removal
-description: >
-  Remove image backgrounds and export transparent PNGs.
-  USE THIS after generating an image when you need a transparent version
-  (e.g., for logos, stickers, overlays). Call remove_image_background(input_path, output_path).
-added_by: CEO
-type: langchain_module
-sprite: desk_equipment

package/company/assets/tools/image_generation/image_generation.py

@@ -1,281 +0,0 @@
-"""Image generation tool via OpenRouter + Gemini image model.
-
-Provides one LangChain @tool:
-- image_generation(requirement, save_path)
-"""
-
-from __future__ import annotations
-
-import base64
-import json
-import os
-import re
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-from langchain_core.tools import tool
-
-_MODEL = "google/gemini-3-pro-image-preview"
-_DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
-_USER_AGENT = "OneManCompany-ImageGeneration/1.0"
-
-
-def _post_json(url: str, headers: dict, payload: dict, timeout: int = 60) -> tuple[dict | None, str | None]:
-    """POST JSON and return (json_body, error)."""
-    req = urllib.request.Request(
-        url,
-        data=json.dumps(payload).encode("utf-8"),
-        headers=headers,
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8", errors="replace")
-        return json.loads(raw), None
-    except urllib.error.HTTPError as e:
-        body_text = e.read().decode("utf-8", errors="replace") if e.fp else ""
-        return None, f"HTTP {e.code}: {body_text[:800]}"
-    except json.JSONDecodeError as e:
-        return None, f"Invalid JSON response: {e}"
-    except Exception as e:
-        return None, str(e)
-
-
-def _mime_to_ext(mime: str) -> str:
-    mapping = {
-        "image/png": ".png",
-        "image/jpeg": ".jpg",
-        "image/jpg": ".jpg",
-        "image/webp": ".webp",
-        "image/gif": ".gif",
-    }
-    return mapping.get(mime.lower(), ".png")
-
-
-def _decode_data_url(data_url: str) -> tuple[bytes | None, str]:
-    """Decode data:image/...;base64,... into bytes."""
-    if not data_url.startswith("data:image/") or "," not in data_url:
-        return None, ""
-    header, payload = data_url.split(",", 1)
-    mime = header.split(";")[0][5:].strip() or "image/png"
-    try:
-        return base64.b64decode(payload), mime
-    except Exception:
-        return None, ""
-
-
-def _decode_base64(payload: str) -> bytes | None:
-    """Decode base64 payload (supports missing padding)."""
-    text = payload.strip()
-    if not text:
-        return None
-    try:
-        return base64.b64decode(text, validate=True)
-    except Exception:
-        pad = "=" * (-len(text) % 4)
-        try:
-            return base64.b64decode(text + pad)
-        except Exception:
-            try:
-                return base64.urlsafe_b64decode(text + pad)
-            except Exception:
-                return None
-
-
-def _download_image(url: str) -> tuple[bytes | None, str]:
-    req = urllib.request.Request(url, headers={"User-Agent": _USER_AGENT})
-    try:
-        with urllib.request.urlopen(req, timeout=60) as resp:
-            data = resp.read()
-            mime = resp.headers.get_content_type() or "image/png"
-            return data, mime
-    except Exception:
-        return None, ""
-
-
-def _extract_data_url_from_text(text: str) -> tuple[bytes | None, str]:
-    """Extract first data:image URL from free text."""
-    m = re.search(r"(data:image/[a-zA-Z0-9.+-]+;base64,[A-Za-z0-9+/=_-]+)", text)
-    if not m:
-        return None, ""
-    return _decode_data_url(m.group(1))
-
-
-def _iter_values(obj):
-    """Yield (key, value) pairs recursively for dict/list trees."""
-    if isinstance(obj, dict):
-        for k, v in obj.items():
-            yield k, v
-            yield from _iter_values(v)
-    elif isinstance(obj, list):
-        for item in obj:
-            yield from _iter_values(item)
-
-
-def _extract_image_bytes(response_json: dict) -> tuple[bytes | None, str]:
-    """Try to extract generated image bytes from multiple response layouts."""
-    # 1) OpenAI Images style: {"data":[{"b64_json":"..."}]}
-    data = response_json.get("data")
-    if isinstance(data, list):
-        for item in data:
-            if not isinstance(item, dict):
-                continue
-            b64_payload = item.get("b64_json") or item.get("image_base64")
-            if isinstance(b64_payload, str):
-                decoded = _decode_base64(b64_payload)
-                if decoded:
-                    return decoded, "image/png"
-            url = item.get("url") or item.get("image_url")
-            if isinstance(url, str):
-                if url.startswith("data:image/"):
-                    decoded, mime = _decode_data_url(url)
-                    if decoded:
-                        return decoded, mime
-                elif url.startswith("http://") or url.startswith("https://"):
-                    downloaded, mime = _download_image(url)
-                    if downloaded:
-                        return downloaded, mime
-
-    # 2) Chat/Responses style variants — recursive scan for common fields
-    base64_keys = {"b64_json", "image_base64", "base64", "b64"}
-    url_keys = {"image_url", "url"}
-    for key, value in _iter_values(response_json):
-        if key in base64_keys and isinstance(value, str):
-            decoded = _decode_base64(value)
-            if decoded:
-                return decoded, "image/png"
-
-        if key in url_keys:
-            url_value = ""
-            if isinstance(value, str):
-                url_value = value
-            elif isinstance(value, dict) and isinstance(value.get("url"), str):
-                url_value = value["url"]
-
-            if url_value.startswith("data:image/"):
-                decoded, mime = _decode_data_url(url_value)
-                if decoded:
-                    return decoded, mime
-            elif url_value.startswith("http://") or url_value.startswith("https://"):
-                downloaded, mime = _download_image(url_value)
-                if downloaded:
-                    return downloaded, mime
-
-        if isinstance(value, str) and "data:image/" in value:
-            decoded, mime = _extract_data_url_from_text(value)
-            if decoded:
-                return decoded, mime
-
-    return None, ""
-
-
-def _build_headers(api_key: str) -> dict:
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-        "User-Agent": _USER_AGENT,
-    }
-    app_name = os.environ.get("OPENROUTER_APP_NAME", "OneManCompany")
-    http_referer = os.environ.get("OPENROUTER_HTTP_REFERER", "http://localhost:8000")
-    if app_name:
-        headers["X-Title"] = app_name
-    if http_referer:
-        headers["HTTP-Referer"] = http_referer
-    return headers
-
-
-@tool
-def image_generation(requirement: str, save_path: str) -> dict:
-    """Generate an image from a text prompt and save it to disk. USE THIS for any image creation task.
-
-    Suitable for: illustrations, logos, banners, icons, marketing visuals, concept art, diagrams.
-    After generating, use remove_image_background if you need a transparent version.
-
-    Args:
-        requirement: Detailed text prompt describing the image to generate. Be specific about style, colors, composition.
-        save_path: Output file path (e.g. /tmp/banner.png).
-    """
-    requirement = (requirement or "").strip()
-    save_path = (save_path or "").strip()
-    if not requirement:
-        return {"status": "error", "message": "requirement is empty"}
-    if not save_path:
-        return {"status": "error", "message": "save_path is empty"}
-
-    api_key = os.environ.get("OPENROUTER_API_KEY", "").strip()
-    if not api_key:
-        return {"status": "error", "message": "OPENROUTER_API_KEY not configured"}
-
-    base_url = os.environ.get("OPENROUTER_BASE_URL", _DEFAULT_BASE_URL).rstrip("/")
-    headers = _build_headers(api_key)
-
-    attempts = [
-        (
-            "chat.completions.text",
-            f"{base_url}/chat/completions",
-            {
-                "model": _MODEL,
-                "messages": [{"role": "user", "content": requirement}],
-            },
-        ),
-        (
-            "chat.completions.multimodal",
-            f"{base_url}/chat/completions",
-            {
-                "model": _MODEL,
-                "messages": [
-                    {
-                        "role": "user",
-                        "content": [{"type": "text", "text": requirement}],
-                    }
-                ],
-            },
-        ),
-        (
-            "responses",
-            f"{base_url}/responses",
-            {
-                "model": _MODEL,
-                "input": requirement,
-            },
-        ),
-    ]
-
-    image_bytes: bytes | None = None
-    image_mime = "image/png"
-    errors: list[str] = []
-
-    for attempt_name, url, payload in attempts:
-        resp_json, err = _post_json(url, headers, payload)
-        if err:
-            errors.append(f"{attempt_name}: {err}")
-            continue
-        assert resp_json is not None
-        image_bytes, image_mime = _extract_image_bytes(resp_json)
-        if image_bytes:
-            break
-        snippet = json.dumps(resp_json, ensure_ascii=False)[:400]
-        errors.append(f"{attempt_name}: no image found, response={snippet}")
-
-    if not image_bytes:
-        return {
-            "status": "error",
-            "message": "Image generation failed on all OpenRouter attempts.",
-            "model": _MODEL,
-            "errors": errors,
-        }
-
-    out = Path(save_path).expanduser()
-    if not out.suffix:
-        out = out.with_suffix(_mime_to_ext(image_mime))
-    out.parent.mkdir(parents=True, exist_ok=True)
-    out.write_bytes(image_bytes)
-
-    return {
-        "status": "ok",
-        "model": _MODEL,
-        "saved_to": str(out),
-        "bytes": len(image_bytes),
-        "mime": image_mime,
-    }

package/company/assets/tools/image_generation/tool.yaml

@@ -1,26 +0,0 @@
-id: image_generation
-name: Image Generation
-description: >
-  Generate images from text prompts (Gemini via OpenRouter).
-  USE THIS whenever a task involves creating images, illustrations, logos, banners,
-  icons, diagrams, or any visual content. Call image_generation(requirement, save_path).
-added_by: CEO
-type: langchain_module
-sprite: desk_equipment
-env_vars:
-  - name: OPENROUTER_API_KEY
-    label: OpenRouter API Key
-    secret: true
-    placeholder: sk-or-v1-...
-  - name: OPENROUTER_BASE_URL
-    label: OpenRouter Base URL
-    secret: false
-    placeholder: https://openrouter.ai/api/v1
-  - name: OPENROUTER_APP_NAME
-    label: OpenRouter App Name
-    secret: false
-    placeholder: OneManCompany
-  - name: OPENROUTER_HTTP_REFERER
-    label: OpenRouter HTTP Referer
-    secret: false
-    placeholder: http://localhost:8000

package/company/assets/tools/video_generation/tool.yaml

@@ -1,15 +0,0 @@
-id: video_generation
-name: Video Generation
-description: >
-  Generate videos from text prompts (Bytedance Seedance 1.5 Pro via fal.ai).
-  USE THIS whenever a task involves creating video content, promotional videos, demos, or animations.
-  Workflow: call video_submit → create a cron task to call video_check_status every 30s →
-  when COMPLETED, call video_download to save the file. Do NOT block-wait.
-added_by: CEO
-type: langchain_module
-sprite: desk_equipment
-env_vars:
-  - name: FAL_API_KEY
-    label: fal.ai API Key
-    secret: true
-    placeholder: "key_id:key_secret"

package/company/assets/tools/video_generation/video_generation.py

@@ -1,267 +0,0 @@
-"""Video generation tool via fal.ai + Bytedance Seedance 1.5 Pro.
-
-Three-step workflow:
-1. video_submit(prompt) → returns status_url + response_url
-2. video_check_status(status_url) → poll via cron task every 30s until COMPLETED
-3. video_download(response_url, save_path) → save video to disk
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-from langchain_core.tools import tool
-
-_MODEL_ID = "fal-ai/bytedance/seedance/v1.5/pro/text-to-video"
-_QUEUE_BASE = "https://queue.fal.run"
-_USER_AGENT = "OneManCompany-VideoGeneration/1.0"
-
-
-# ── HTTP helpers ──────────────────────────────────────────
-
-
-def _get_api_key() -> str | None:
-    key = os.environ.get("FAL_KEY", "") or os.environ.get("FAL_API_KEY", "")
-    return key.strip() or None
-
-
-def _build_headers(api_key: str) -> dict:
-    return {
-        "Authorization": f"Key {api_key}",
-        "Content-Type": "application/json",
-        "User-Agent": _USER_AGENT,
-    }
-
-
-def _request_json(
-    method: str,
-    url: str,
-    headers: dict,
-    payload: dict | None = None,
-    timeout: int = 120,
-) -> tuple[dict | None, str | None]:
-    """Make an HTTP request and return (json_body, error)."""
-    data = json.dumps(payload).encode("utf-8") if payload else None
-    req = urllib.request.Request(url, data=data, headers=headers, method=method)
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8", errors="replace")
-        return json.loads(raw), None
-    except urllib.error.HTTPError as e:
-        body_text = e.read().decode("utf-8", errors="replace") if e.fp else ""
-        return None, f"HTTP {e.code}: {body_text[:800]}"
-    except json.JSONDecodeError as e:
-        return None, f"Invalid JSON response: {e}"
-    except Exception as e:
-        return None, str(e)
-
-
-def _download_file(url: str, timeout: int = 300) -> tuple[bytes | None, str]:
-    """Download a file from URL, return (bytes, error_or_content_type)."""
-    req = urllib.request.Request(url, headers={"User-Agent": _USER_AGENT})
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            data = resp.read()
-            ct = resp.headers.get_content_type() or "video/mp4"
-            return data, ct
-    except Exception as e:
-        return None, str(e)
-
-
-# ── Tool 1: Submit ────────────────────────────────────────
-
-
-@tool
-def video_submit(
-    prompt: str,
-    duration: str = "5",
-    aspect_ratio: str = "16:9",
-    resolution: str = "720p",
-    generate_audio: bool = True,
-) -> dict:
-    """Submit a text-to-video generation request. USE THIS for any video creation task.
-
-    This is Step 1 of 3 for video generation:
-    1. Call video_submit(prompt) → get status_url and response_url
-    2. Create a cron task to call video_check_status(status_url) every 30 seconds
-    3. When status is COMPLETED, call video_download(response_url, save_path)
-
-    Args:
-        prompt: Detailed description of the video to generate. Be specific about scenes, motion, style.
-        duration: Video length: "auto", or "4" through "15" seconds (default: "5").
-        aspect_ratio: "auto", "21:9", "16:9", "4:3", "1:1", "3:4", "9:16" (default: "16:9").
-        resolution: "480p" or "720p" (default: "720p").
-        generate_audio: Whether to generate audio (default: True, doubles cost).
-    """
-    prompt = (prompt or "").strip()
-    if not prompt:
-        return {"status": "error", "message": "prompt is empty"}
-
-    api_key = _get_api_key()
-    if not api_key:
-        return {"status": "error", "message": "FAL_KEY or FAL_API_KEY not configured"}
-
-    headers = _build_headers(api_key)
-    payload = {
-        "prompt": prompt,
-        "duration": str(duration),
-        "aspect_ratio": aspect_ratio,
-        "resolution": resolution,
-        "generate_audio": generate_audio,
-    }
-
-    url = f"{_QUEUE_BASE}/{_MODEL_ID}"
-    resp, err = _request_json("POST", url, headers, payload, timeout=30)
-    if err:
-        return {"status": "error", "message": f"Failed to submit: {err}"}
-
-    assert resp is not None
-    request_id = resp.get("request_id")
-    if not request_id:
-        return {"status": "error", "message": f"No request_id: {json.dumps(resp)[:400]}"}
-
-    return {
-        "status": "ok",
-        "message": (
-            f"Video generation submitted! request_id: {request_id}. "
-            "Generation typically takes 1-5 minutes. "
-            "Create a cron task to call video_check_status every 30-60 seconds "
-            "with the status_url below. Once COMPLETED, call video_download "
-            "with the response_url below and a save_path."
-        ),
-        "request_id": request_id,
-        "status_url": resp.get("status_url"),
-        "response_url": resp.get("response_url"),
-        "cancel_url": resp.get("cancel_url"),
-        "queue_position": resp.get("queue_position"),
-    }
-
-
-# ── Tool 2: Check Status ─────────────────────────────────
-
-
-@tool
-def video_check_status(status_url: str) -> dict:
-    """Check if a submitted video generation is done (Step 2 of 3).
-
-    Call this via cron task every 30 seconds after video_submit.
-    When generation_status is COMPLETED → call video_download.
-    When FAILED → stop the cron task and report the error.
-
-    Args:
-        status_url: The status_url returned by video_submit.
-    """
-    status_url = (status_url or "").strip()
-    if not status_url:
-        return {"status": "error", "message": "status_url is empty"}
-
-    api_key = _get_api_key()
-    if not api_key:
-        return {"status": "error", "message": "FAL_KEY or FAL_API_KEY not configured"}
-
-    headers = _build_headers(api_key)
-    resp, err = _request_json("GET", status_url, headers, timeout=30)
-    if err:
-        return {"status": "error", "message": f"Failed to check status: {err}"}
-
-    assert resp is not None
-    gen_status = resp.get("status", "UNKNOWN")
-
-    result = {
-        "status": "ok",
-        "generation_status": gen_status,
-        "request_id": resp.get("request_id"),
-    }
-
-    if gen_status == "IN_QUEUE":
-        result["queue_position"] = resp.get("queue_position")
-        result["message"] = "Still in queue. Check again in 30-60 seconds."
-    elif gen_status == "IN_PROGRESS":
-        result["message"] = "Video is being generated. Check again in 30-60 seconds."
-    elif gen_status == "COMPLETED":
-        result["message"] = (
-            "Video generation is complete! "
-            "Call video_download with the response_url and a save_path to download it. "
-            "You can cancel the cron task now."
-        )
-        result["inference_time"] = (resp.get("metrics") or {}).get("inference_time")
-    elif gen_status in ("FAILED", "ERROR", "CANCELLED", "CANCELED"):
-        result["message"] = f"Generation failed: {resp.get('error', 'unknown error')}. You can cancel the cron task now."
-    else:
-        result["message"] = f"Unknown status: {gen_status}. Check again in 30 seconds."
-
-    return result
-
-
-# ── Tool 3: Download ──────────────────────────────────────
-
-
-@tool
-def video_download(response_url: str, save_path: str) -> dict:
-    """Download a completed video to disk (Step 3 of 3).
-
-    Call this after video_check_status returns COMPLETED. Stop the cron task after downloading.
-
-    Args:
-        response_url: The response_url returned by video_submit.
-        save_path: Output file path (e.g. /tmp/my_video.mp4).
-    """
-    response_url = (response_url or "").strip()
-    save_path = (save_path or "").strip()
-    if not response_url:
-        return {"status": "error", "message": "response_url is empty"}
-    if not save_path:
-        return {"status": "error", "message": "save_path is empty"}
-
-    api_key = _get_api_key()
-    if not api_key:
-        return {"status": "error", "message": "FAL_KEY or FAL_API_KEY not configured"}
-
-    headers = _build_headers(api_key)
-
-    # Fetch the result
-    resp, err = _request_json("GET", response_url, headers, timeout=60)
-    if err:
-        return {"status": "error", "message": f"Failed to fetch result: {err}"}
-
-    assert resp is not None
-
-    # Extract video URL — fal.ai format: {"video": {"url": "...", ...}}
-    video_info = resp.get("video", {})
-    video_url = video_info.get("url") if isinstance(video_info, dict) else None
-    if not video_url:
-        snippet = json.dumps(resp, ensure_ascii=False)[:400]
-        return {
-            "status": "error",
-            "message": f"No video URL in result: {snippet}",
-        }
-
-    # Download
-    video_bytes, content_type = _download_file(video_url)
-    if not video_bytes:
-        return {
-            "status": "error",
-            "message": f"Failed to download video: {content_type}",
-            "video_url": video_url,
-        }
-
-    # Save to disk
-    out = Path(save_path).expanduser()
-    if not out.suffix:
-        out = out.with_suffix(".mp4")
-    out.parent.mkdir(parents=True, exist_ok=True)
-    out.write_bytes(video_bytes)
-
-    return {
-        "status": "ok",
-        "model": _MODEL_ID,
-        "saved_to": str(out),
-        "bytes": len(video_bytes),
-        "content_type": video_info.get("content_type", content_type),
-        "video_url": video_url,
-        "seed": resp.get("seed"),
-    }