__init__.py 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155
  1. """DeepInfra image generation (FLUX, Qwen-Image-Edit, …) via the OpenAI-compatible
  2. ``/v1/openai/images/generations`` endpoint. The catalog is fully dynamic (``image-gen``-tagged
  3. models from :func:`hermes_cli.models._fetch_deepinfra_models_by_tag`; no ids hardcoded).
  4. Selection: ``DEEPINFRA_IMAGE_MODEL`` → ``image_gen.deepinfra.model`` → first live model;
  5. when all are absent ``generate()`` errors rather than guessing."""
  6. from __future__ import annotations
  7. import logging
  8. import os
  9. from typing import Any, Dict, List, Optional
  10. from agent.secret_scope import get_secret
  11. from agent.image_gen_provider import DEFAULT_ASPECT_RATIO, resolve_aspect_ratio, success_response
  12. from plugins.image_gen._common import (
  13. StaticImageGenProvider, error_factory, import_openai, load_image_gen_config, materialize_image,
  14. prompt_required_error, size_for)
  15. logger = logging.getLogger(__name__)
  16. def _live_models() -> Optional[list[dict[str, Any]]]:
  17. """Fetch ``image-gen``-tagged models from the DeepInfra catalog."""
  18. try:
  19. from hermes_cli.models import _fetch_deepinfra_models_by_tag
  20. except Exception as exc:
  21. logger.debug("Cannot import _fetch_deepinfra_models_by_tag: %s", exc)
  22. return None
  23. return _fetch_deepinfra_models_by_tag("image-gen")
  24. def _format_catalog_row(item: dict[str, Any]) -> dict[str, Any]:
  25. """Picker row for a catalog item."""
  26. mid = item.get("id", "")
  27. metadata = item.get("metadata")
  28. metadata = metadata if isinstance(metadata, dict) else {}
  29. row: dict[str, Any] = {
  30. "id": mid, "display": mid.split("/", 1)[-1], "strengths": metadata.get("description", ""),
  31. }
  32. pricing = metadata.get("pricing")
  33. if isinstance(pricing, dict) and pricing.get("per_image_unit") is not None:
  34. try:
  35. row["price"] = f"${float(pricing['per_image_unit']):.4f}/image"
  36. except (TypeError, ValueError):
  37. pass
  38. for key in ("default_width", "default_height", "default_iterations"):
  39. if metadata.get(key) is not None:
  40. row[key] = metadata[key]
  41. return row
  42. def _resolve_model(catalog: list[dict[str, Any]], cfg: dict[str, Any]) -> Optional[str]:
  43. """env > config > first live result, else None (``cfg`` = loaded ``image_gen.deepinfra``)."""
  44. env_override = os.environ.get("DEEPINFRA_IMAGE_MODEL", "").strip()
  45. if env_override:
  46. return env_override
  47. cfg_model = cfg.get("model") if isinstance(cfg, dict) else None
  48. if isinstance(cfg_model, str) and cfg_model.strip():
  49. return cfg_model.strip()
  50. first = catalog[0].get("id") if catalog else None
  51. return first if isinstance(first, str) and first else None
  52. class DeepInfraImageGenProvider(StaticImageGenProvider):
  53. """DeepInfra ``images.generations`` backend; catalog discovered live by the ``image-gen`` tag."""
  54. provider_id = "deepinfra"
  55. label = "DeepInfra"
  56. setup = dict(
  57. name="DeepInfra", badge="paid", tag="FLUX, Qwen-Image, … — live catalog from api.deepinfra.com",
  58. key="DEEPINFRA_API_KEY", prompt="DeepInfra API key", url="https://deepinfra.com/dash/api_keys",
  59. )
  60. def is_available(self) -> bool:
  61. return bool((get_secret("DEEPINFRA_API_KEY", "") or "").strip())
  62. def list_models(self) -> list[dict[str, Any]]:
  63. return [_format_catalog_row(item) for item in _live_models() or []]
  64. def default_model(self) -> Optional[str]:
  65. rows = self.list_models()
  66. return rows[0].get("id") if rows else None
  67. def capabilities(self) -> dict[str, Any]:
  68. """DeepInfra's OpenAI-compatible generation surface is text-only."""
  69. return {"modalities": ["text"], "max_reference_images": 0}
  70. def generate(self, prompt: str, aspect_ratio: str = DEFAULT_ASPECT_RATIO, **kwargs: Any) -> dict[str, Any]:
  71. prompt = (prompt or "").strip()
  72. aspect = resolve_aspect_ratio(aspect_ratio)
  73. fail = error_factory("deepinfra", aspect)
  74. if kwargs.get("image_url") or kwargs.get("reference_image_urls"):
  75. return fail(
  76. "DeepInfra image generation is text-to-image only in this "
  77. "backend; image_url and reference_image_urls are unsupported.",
  78. "modality_unsupported", prompt=prompt)
  79. if not prompt:
  80. return prompt_required_error("deepinfra", aspect)
  81. api_key = (get_secret("DEEPINFRA_API_KEY", "") or "").strip()
  82. if not api_key:
  83. return fail(
  84. "DEEPINFRA_API_KEY not set. Run `hermes tools` → Image "
  85. "Generation → DeepInfra to configure, or `hermes setup` "
  86. "to add the key.",
  87. "auth_required")
  88. di_cfg = load_image_gen_config("deepinfra")
  89. model_id = _resolve_model(_live_models() or [], di_cfg)
  90. if not model_id:
  91. return fail(
  92. "No DeepInfra image-gen model available. Pin one in "
  93. "config.yaml under image_gen.deepinfra.model, set "
  94. "DEEPINFRA_IMAGE_MODEL, or check connectivity to "
  95. "api.deepinfra.com so the live catalog can be fetched.",
  96. "no_model_available", prompt=prompt)
  97. size = size_for(aspect)
  98. from hermes_cli.models import deepinfra_base_url
  99. # The openai SDK supplies retry, timeout and error mapping.
  100. openai, err = import_openai("deepinfra", aspect)
  101. if err:
  102. return err
  103. fail = error_factory("deepinfra", aspect, model=model_id, prompt=prompt)
  104. client = openai.OpenAI(api_key=api_key, base_url=deepinfra_base_url(di_cfg))
  105. try:
  106. response = client.images.generate(model=model_id, prompt=prompt, size=size, n=1)
  107. except Exception as exc:
  108. logger.debug("DeepInfra image generation failed", exc_info=True)
  109. return fail(f"DeepInfra image generation failed: {exc}", "api_error")
  110. finally:
  111. close = getattr(client, "close", None)
  112. if callable(close):
  113. close()
  114. data = getattr(response, "data", None) or []
  115. if not data:
  116. return fail("DeepInfra returned no image data", "empty_response")
  117. first = data[0]
  118. # Prefix drops ``vendor/`` and colons (single path component on every OS); delivery URLs
  119. # are short-lived, so materialise locally best-effort.
  120. image_ref, err = materialize_image(
  121. getattr(first, "b64_json", None), getattr(first, "url", None),
  122. prefix=f"deepinfra_{model_id.split('/', 1)[-1].replace(':', '_')}", label="DeepInfra",
  123. provider="deepinfra", model=model_id, prompt=prompt, aspect=aspect,
  124. on_url_fail=lambda exc: logger.debug(
  125. "DeepInfra: caching delivery URL failed (%s); returning URL", exc))
  126. if err:
  127. return err
  128. return success_response(
  129. image=image_ref, model=model_id, prompt=prompt, aspect_ratio=aspect, provider="deepinfra",
  130. extra={"size": size})
  131. def register(ctx) -> None:
  132. """Plugin entry point — wire ``DeepInfraImageGenProvider`` into the registry."""
  133. ctx.register_image_gen_provider(DeepInfraImageGenProvider())