timbal 2.2.0__tar.gz → 2.2.1__tar.gz

{timbal-2.2.0 → timbal-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: timbal
-Version: 2.2.0
+Version: 2.2.1
 Summary: Simple, performant, battle-tested framework for building reliable AI applications
 Project-URL: Source, https://github.com/timbal-ai/timbal
 Author-email: Timbal <team@timbal.ai>

{timbal-2.2.0 → timbal-2.2.1}/python/timbal/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.2.1'
+__version_tuple__ = version_tuple = (2, 2, 1)
 
 __commit_id__ = commit_id = None

{timbal-2.2.0 → timbal-2.2.1}/python/timbal/codegen/flow.py

@@ -71,8 +71,20 @@ def _extract_key_from_lambda(fn: Any, source_step: str) -> str | None:
 
 
 def _is_model_enum(values: list) -> bool:
-    """Return True if a list of enum values looks like LLM model IDs (provider/name)."""
-    return len(values) > 5 and all(isinstance(v, str) and "/" in v for v in values[:5])
+    """Return True if an enum is the canonical LLM model ID set (provider/name).
+
+    Matches against ``timbal.core.models.Model`` rather than guessing from shape:
+    other registries (e.g. Krea's image/video IDs) share the ``provider/name``
+    form but must keep their enum inline so editors resolve the right options.
+    """
+    if len(values) <= 5 or not all(isinstance(v, str) and "/" in v for v in values[:5]):
+        return False
+    import typing
+
+    from timbal.core.models import Model
+
+    known = set(typing.get_args(Model))
+    return all(v in known for v in values)
 
 
 def _compact_field(field: dict) -> dict:

{timbal-2.2.0 → timbal-2.2.1}/python/timbal/tools/krea.py

@@ -26,6 +26,72 @@ _FAILED_STATUSES = frozenset({"failed", "cancelled"})
 
 MediaKind = Literal["video", "image"]
 
+# Model identifiers map directly to Krea's POST /generate/{media}/{provider}/{model} endpoints.
+# Source of truth: https://api.krea.ai/openapi.json. Update when Krea adds/removes models.
+KreaImageModel = Literal[
+    "bfl/flux-1-dev",
+    "bfl/flux-1-kontext-dev",
+    "bfl/flux-1.1-pro",
+    "bfl/flux-1.1-pro-ultra",
+    "bytedance/seededit",
+    "bytedance/seedream-4",
+    "bytedance/seedream-5-lite",
+    "google/imagen-3",
+    "google/imagen-4",
+    "google/imagen-4-fast",
+    "google/imagen-4-ultra",
+    "google/nano-banana",
+    "google/nano-banana-2",
+    "google/nano-banana-pro",
+    "ideogram/ideogram-2-turbo",
+    "ideogram/ideogram-3",
+    "krea/krea-2/large",
+    "krea/krea-2/medium",
+    "krea/krea-2/medium-turbo",
+    "luma/uni-1",
+    "openai/gpt-image",
+    "openai/gpt-image-2",
+    "qwen/2512",
+    "runway/gen-4-image",
+    "z-image/z-image",
+]
+
+KreaVideoModel = Literal[
+    "alibaba/wan-2.1",
+    "alibaba/wan-2.2",
+    "alibaba/wan-2.5",
+    "bytedance/seedance-1.0-pro",
+    "bytedance/seedance-1.0-pro-fast",
+    "bytedance/seedance-2",
+    "bytedance/seedance-2-fast",
+    "google/veo-2",
+    "google/veo-3",
+    "google/veo-3-fast",
+    "google/veo-3.1",
+    "google/veo-3.1-fast",
+    "google/veo-3.1-lite",
+    "kling/kling-1",
+    "kling/kling-1.5",
+    "kling/kling-1.6",
+    "kling/kling-2",
+    "kling/kling-2.1",
+    "kling/kling-2.5",
+    "kling/kling-2.6",
+    "kling/kling-3.0",
+    "kling/kling-o1",
+    "lightricks/ltx-video-2.3-22b",
+    "luma/ray-2",
+    "minimax/hailuo",
+    "minimax/hailuo-02",
+    "minimax/hailuo-2.3",
+    "minimax/hailuo-2.3-fast",
+    "runway/aleph",
+    "runway/gen-3",
+    "runway/gen-4-video",
+    "runway/gen-4.5",
+    "xai/grok-video",
+]
+
 
 def _krea_headers(api_key: str, *, webhook_url: str | None = None) -> dict[str, str]:
     headers = {
@@ -248,9 +314,9 @@ class KreaGenerateVideo(Tool):
     def __init__(self, **kwargs: Any) -> None:
         async def _krea_generate_video(
             prompt: str = Field(..., description="Text description of the video to generate."),
-            model: str = Field(
+            model: KreaVideoModel = Field(
                 "google/veo-3.1-fast",
-                description="Krea video model path: provider/model (e.g. google/veo-3.1-fast).",
+                description="Krea video model as provider/model (e.g. google/veo-3.1-fast, kling/kling-2.5).",
             ),
             aspect_ratio: str = Field("16:9", description="Aspect ratio when supported by the model."),
             duration: int | None = Field(None, description="Duration in seconds when supported by the model."),
@@ -279,89 +345,74 @@ class KreaGenerateVideo(Tool):
             start = time.monotonic()
             resolved_model = model.strip()
 
-            try:
-                if not prompt or not prompt.strip():
-                    raise ValueError("prompt is required and must be non-empty")
-
-                payload: dict[str, Any] = {"prompt": prompt.strip()}
-                if aspect_ratio:
-                    payload["aspect_ratio"] = aspect_ratio
-                if duration is not None:
-                    payload["duration"] = duration
-                if resolution is not None:
-                    payload["resolution"] = resolution
-                if generate_audio is not None:
-                    payload["generate_audio"] = generate_audio
-                if start_image:
-                    payload["start_image"] = start_image
-                if end_image:
-                    payload["end_image"] = end_image
-                if reference_images:
-                    payload["reference_images"] = reference_images
-                if provider_params:
-                    for key, value in provider_params.items():
-                        if value is not None:
-                            payload[key] = value
-
-                path = _build_generate_path("video", resolved_model)
-                api_key = await resolve_api_key(tool=self, provider_name="Krea", env_var="KREA_API_KEY")
-                import httpx
-
-                async with httpx.AsyncClient(timeout=httpx.Timeout(60.0, read=None)) as client:
-                    submit = await client.post(
-                        f"{_KREA_BASE}{path}",
-                        headers=_krea_headers(api_key, webhook_url=webhook_url),
-                        json=payload,
-                    )
-                    await _raise_for_krea_response(submit)
-                    submit_data = submit.json()
-
-                    job_id = submit_data.get("job_id")
-                    if not isinstance(job_id, str) or not job_id:
-                        raise ValueError(f"Krea video API returned no job_id: {submit_data}")
-
-                    job = await _poll_krea_job(
-                        client,
-                        api_key=api_key,
-                        job_id=job_id,
-                        poll_interval=poll_interval,
-                        timeout=timeout,
-                    )
-
-                urls = _extract_job_urls(job)
-                if not urls:
-                    raise ValueError(f"No output URLs in completed Krea job: {job}")
-
-                elapsed = time.monotonic() - start
-                logger.info(
-                    "Krea video generated",
-                    model=resolved_model,
+            if not prompt or not prompt.strip():
+                raise ValueError("prompt is required and must be non-empty")
+
+            payload: dict[str, Any] = {"prompt": prompt.strip()}
+            if aspect_ratio:
+                payload["aspect_ratio"] = aspect_ratio
+            if duration is not None:
+                payload["duration"] = duration
+            if resolution is not None:
+                payload["resolution"] = resolution
+            if generate_audio is not None:
+                payload["generate_audio"] = generate_audio
+            if start_image:
+                payload["start_image"] = start_image
+            if end_image:
+                payload["end_image"] = end_image
+            if reference_images:
+                payload["reference_images"] = reference_images
+            if provider_params:
+                for key, value in provider_params.items():
+                    if value is not None:
+                        payload[key] = value
+
+            path = _build_generate_path("video", resolved_model)
+            api_key = await resolve_api_key(tool=self, provider_name="Krea", env_var="KREA_API_KEY")
+            import httpx
+
+            async with httpx.AsyncClient(timeout=httpx.Timeout(60.0, read=None)) as client:
+                submit = await client.post(
+                    f"{_KREA_BASE}{path}",
+                    headers=_krea_headers(api_key, webhook_url=webhook_url),
+                    json=payload,
+                )
+                await _raise_for_krea_response(submit)
+                submit_data = submit.json()
+
+                job_id = submit_data.get("job_id")
+                if not isinstance(job_id, str) or not job_id:
+                    raise ValueError(f"Krea video API returned no job_id: {submit_data}")
+
+                job = await _poll_krea_job(
+                    client,
+                    api_key=api_key,
                     job_id=job_id,
-                    elapsed_s=round(elapsed, 2),
+                    poll_interval=poll_interval,
+                    timeout=timeout,
                 )
-                return {
-                    "success": True,
-                    "model": resolved_model,
-                    "job_id": job_id,
-                    "video_url": urls[0],
-                    "urls": urls,
-                    "job": job,
-                    "elapsed_seconds": round(elapsed, 2),
-                }
-
-            except Exception as exc:
-                elapsed = time.monotonic() - start
-                logger.error("Krea video generation failed", model=resolved_model, error=str(exc))
-                return {
-                    "success": False,
-                    "model": resolved_model,
-                    "job_id": None,
-                    "video_url": None,
-                    "urls": [],
-                    "error": str(exc),
-                    "error_type": type(exc).__name__,
-                    "elapsed_seconds": round(elapsed, 2),
-                }
+
+            urls = _extract_job_urls(job)
+            if not urls:
+                raise ValueError(f"No output URLs in completed Krea job: {job}")
+
+            elapsed = time.monotonic() - start
+            logger.info(
+                "Krea video generated",
+                model=resolved_model,
+                job_id=job_id,
+                elapsed_s=round(elapsed, 2),
+            )
+            return {
+                "success": True,
+                "model": resolved_model,
+                "job_id": job_id,
+                "video_url": urls[0],
+                "urls": urls,
+                "job": job,
+                "elapsed_seconds": round(elapsed, 2),
+            }
 
         super().__init__(handler=_krea_generate_video, **kwargs)
 
@@ -385,9 +436,9 @@ class KreaGenerateImage(Tool):
     def __init__(self, **kwargs: Any) -> None:
         async def _krea_generate_image(
             prompt: str = Field(..., description="Text description of the image to generate."),
-            model: str = Field(
+            model: KreaImageModel = Field(
                 "bfl/flux-1-dev",
-                description="Krea image model path: provider/model (e.g. bfl/flux-1-dev).",
+                description="Krea image model as provider/model (e.g. bfl/flux-1-dev, krea/krea-2/large).",
             ),
             width: int | None = Field(None, description="Output width in pixels when supported."),
             height: int | None = Field(None, description="Output height in pixels when supported."),
@@ -407,82 +458,67 @@ class KreaGenerateImage(Tool):
             start = time.monotonic()
             resolved_model = model.strip()
 
-            try:
-                if not prompt or not prompt.strip():
-                    raise ValueError("prompt is required and must be non-empty")
-
-                payload: dict[str, Any] = {"prompt": prompt.strip()}
-                if width is not None:
-                    payload["width"] = width
-                if height is not None:
-                    payload["height"] = height
-                if seed is not None:
-                    payload["seed"] = seed
-                if image_url:
-                    payload["image_url"] = image_url
-                if provider_params:
-                    for key, value in provider_params.items():
-                        if value is not None:
-                            payload[key] = value
-
-                path = _build_generate_path("image", resolved_model)
-                api_key = await resolve_api_key(tool=self, provider_name="Krea", env_var="KREA_API_KEY")
-                import httpx
-
-                async with httpx.AsyncClient(timeout=httpx.Timeout(60.0, read=None)) as client:
-                    submit = await client.post(
-                        f"{_KREA_BASE}{path}",
-                        headers=_krea_headers(api_key, webhook_url=webhook_url),
-                        json=payload,
-                    )
-                    await _raise_for_krea_response(submit)
-                    submit_data = submit.json()
-
-                    job_id = submit_data.get("job_id")
-                    if not isinstance(job_id, str) or not job_id:
-                        raise ValueError(f"Krea image API returned no job_id: {submit_data}")
-
-                    job = await _poll_krea_job(
-                        client,
-                        api_key=api_key,
-                        job_id=job_id,
-                        poll_interval=poll_interval,
-                        timeout=timeout,
-                    )
-
-                urls = _extract_job_urls(job)
-                if not urls:
-                    raise ValueError(f"No output URLs in completed Krea job: {job}")
-
-                elapsed = time.monotonic() - start
-                logger.info(
-                    "Krea image generated",
-                    model=resolved_model,
+            if not prompt or not prompt.strip():
+                raise ValueError("prompt is required and must be non-empty")
+
+            payload: dict[str, Any] = {"prompt": prompt.strip()}
+            if width is not None:
+                payload["width"] = width
+            if height is not None:
+                payload["height"] = height
+            if seed is not None:
+                payload["seed"] = seed
+            if image_url:
+                payload["image_url"] = image_url
+            if provider_params:
+                for key, value in provider_params.items():
+                    if value is not None:
+                        payload[key] = value
+
+            path = _build_generate_path("image", resolved_model)
+            api_key = await resolve_api_key(tool=self, provider_name="Krea", env_var="KREA_API_KEY")
+            import httpx
+
+            async with httpx.AsyncClient(timeout=httpx.Timeout(60.0, read=None)) as client:
+                submit = await client.post(
+                    f"{_KREA_BASE}{path}",
+                    headers=_krea_headers(api_key, webhook_url=webhook_url),
+                    json=payload,
+                )
+                await _raise_for_krea_response(submit)
+                submit_data = submit.json()
+
+                job_id = submit_data.get("job_id")
+                if not isinstance(job_id, str) or not job_id:
+                    raise ValueError(f"Krea image API returned no job_id: {submit_data}")
+
+                job = await _poll_krea_job(
+                    client,
+                    api_key=api_key,
                     job_id=job_id,
-                    elapsed_s=round(elapsed, 2),
+                    poll_interval=poll_interval,
+                    timeout=timeout,
                 )
-                return {
-                    "success": True,
-                    "model": resolved_model,
-                    "job_id": job_id,
-                    "image_url": urls[0],
-                    "urls": urls,
-                    "job": job,
-                    "elapsed_seconds": round(elapsed, 2),
-                }
-
-            except Exception as exc:
-                elapsed = time.monotonic() - start
-                logger.error("Krea image generation failed", model=resolved_model, error=str(exc))
-                return {
-                    "success": False,
-                    "model": resolved_model,
-                    "job_id": None,
-                    "image_url": None,
-                    "urls": [],
-                    "error": str(exc),
-                    "error_type": type(exc).__name__,
-                    "elapsed_seconds": round(elapsed, 2),
-                }
+
+            urls = _extract_job_urls(job)
+            if not urls:
+                raise ValueError(f"No output URLs in completed Krea job: {job}")
+
+            elapsed = time.monotonic() - start
+            logger.info(
+                "Krea image generated",
+                model=resolved_model,
+                job_id=job_id,
+                elapsed_s=round(elapsed, 2),
+            )
+            return {
+                "success": True,
+                "model": resolved_model,
+                "job_id": job_id,
+                "image_url": urls[0],
+                "urls": urls,
+                "job": job,
+                "elapsed_seconds": round(elapsed, 2),
+            }
 
         super().__init__(handler=_krea_generate_image, **kwargs)