__init__.py 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130
  1. """Meta Model API (``muse-image``): OpenAI-compatible (https://api.meta.ai/v1), so the OpenAI SDK
  2. is pointed at Meta's base URL with ``META_MODEL_API_KEY``. Output is base64 WebP → image cache.
  3. Selection: ``model`` kwarg → ``META_IMAGE_MODEL`` → ``image_gen.meta-ai.model`` → ``image_gen.model``
  4. → :data:`DEFAULT_MODEL`."""
  5. from __future__ import annotations
  6. import logging
  7. from typing import Any, Dict, List, Optional, Tuple
  8. from agent.secret_scope import get_secret, get_secret_str
  9. from agent.image_gen_provider import (
  10. DEFAULT_ASPECT_RATIO, resolve_aspect_ratio, save_b64_image, save_url_image, success_response)
  11. from plugins.image_gen._common import (
  12. StaticImageGenProvider, error_factory, import_openai, openai_importable, prompt_required_error,
  13. resolve_static_model, size_for)
  14. logger = logging.getLogger(__name__)
  15. DEFAULT_BASE_URL = "https://api.meta.ai/v1"
  16. # Auth env vars in priority order (mirrors the ``meta-ai`` chat provider); MODEL_API_KEY is Meta's
  17. # documented var, the rest are aliases. ``API_KEY_ENV`` is the one shown in setup/errors.
  18. API_KEY_ENVS = ("MODEL_API_KEY", "META_API_KEY", "META_MODEL_API_KEY")
  19. API_KEY_ENV = "META_MODEL_API_KEY"
  20. BASE_URL_ENV = "META_BASE_URL" # optional override, same var the chat provider honors
  21. def _resolve_api_key() -> Optional[str]:
  22. """First non-empty auth env var, in priority order."""
  23. return next((val for val in map(get_secret, API_KEY_ENVS) if val), None)
  24. def _resolve_base_url() -> str:
  25. # Through the secret scope like the key: under multiplexing os.environ holds the launch profile's
  26. # endpoint, and a routed profile's key must never be sent to another profile's base URL.
  27. return get_secret_str(BASE_URL_ENV).strip() or DEFAULT_BASE_URL
  28. # Model ids are sent verbatim to ``/v1/images/generations``.
  29. _MODELS: dict[str, dict[str, Any]] = {
  30. "muse-image-1.0": {
  31. "display": "Muse Image 1.0",
  32. "speed": "~10s",
  33. "strengths": "Meta Model API image generation",
  34. "price": "$0.01/image",
  35. },
  36. }
  37. DEFAULT_MODEL = "muse-image-1.0"
  38. def _resolve_model(caller_model: Optional[str] = None) -> tuple[str, dict[str, Any]]:
  39. return resolve_static_model(
  40. _MODELS, DEFAULT_MODEL, env_var="META_IMAGE_MODEL", config_key="meta-ai", explicit=caller_model,
  41. )
  42. class MetaImageGenProvider(StaticImageGenProvider):
  43. """Meta Model API ``images.generate`` backend (muse-image)."""
  44. provider_id = "meta-ai"
  45. label = "Meta Model API"
  46. models = _MODELS
  47. default_model_id = DEFAULT_MODEL
  48. setup = dict(
  49. name="Meta Model API", badge="paid", tag="Muse Image via Meta Model API (api.meta.ai)",
  50. key=API_KEY_ENV, prompt="Meta Model API key (LLM|... token)", url="https://api.meta.ai")
  51. def is_available(self) -> bool:
  52. return bool(_resolve_api_key()) and openai_importable()
  53. def capabilities(self) -> dict[str, Any]:
  54. # Text-to-image only until image-to-image is verified against Meta.
  55. return {"modalities": ["text"], "max_reference_images": 0}
  56. def generate(
  57. self, prompt: str, aspect_ratio: str = DEFAULT_ASPECT_RATIO, *,
  58. image_url: Optional[str] = None, reference_image_urls: Optional[list[str]] = None,
  59. **kwargs: Any,
  60. ) -> dict[str, Any]:
  61. prompt = (prompt or "").strip()
  62. aspect = resolve_aspect_ratio(aspect_ratio)
  63. if not prompt:
  64. return prompt_required_error("meta-ai", aspect)
  65. api_key = _resolve_api_key()
  66. if not api_key:
  67. return error_factory("meta-ai", aspect)(
  68. f"{API_KEY_ENV} not set. Run `hermes tools` -> Image "
  69. "Generation -> Meta Model API to configure.",
  70. "auth_required")
  71. openai, err = import_openai("meta-ai", aspect)
  72. if err:
  73. return err
  74. model_id, _meta = _resolve_model(kwargs.get("model"))
  75. size = size_for(aspect)
  76. fail = error_factory("meta-ai", aspect, model=model_id, prompt=prompt)
  77. client = openai.OpenAI(api_key=api_key, base_url=_resolve_base_url())
  78. try:
  79. response = client.images.generate(model=model_id, prompt=prompt, size=size, n=1)
  80. except Exception as exc:
  81. logger.debug("Meta image generation failed", exc_info=True)
  82. return fail(f"Meta image generation failed: {exc}", "api_error")
  83. try:
  84. first = response.data[0]
  85. except (AttributeError, IndexError, TypeError):
  86. return fail("Meta response contained no image data", "empty_response")
  87. b64 = getattr(first, "b64_json", None)
  88. url = getattr(first, "url", None)
  89. try:
  90. if b64:
  91. image_ref = str(save_b64_image(b64, prefix="meta", extension="webp"))
  92. elif url:
  93. image_ref = str(save_url_image(url, prefix="meta"))
  94. else:
  95. return fail("Meta response contained neither b64_json nor URL", "empty_response")
  96. except Exception as exc:
  97. return fail(f"Failed to save Meta image: {exc}", "io_error")
  98. extra: dict[str, Any] = {"size": size}
  99. if getattr(first, "revised_prompt", None):
  100. extra["revised_prompt"] = first.revised_prompt
  101. return success_response(
  102. image=image_ref, model=model_id, prompt=prompt, aspect_ratio=aspect, provider="meta-ai",
  103. modality="text", extra=extra)
  104. def register(ctx) -> None:
  105. """Plugin entry point -- wire ``MetaImageGenProvider`` into the registry."""
  106. ctx.register_image_gen_provider(MetaImageGenProvider())