intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/venice_image/image_generation/image_generation_base.py

@@ -0,0 +1,117 @@
+import base64
+import hashlib
+import logging
+from typing import Any, Dict, Literal, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+# Import the generic base
+from intentkit.skills.base import ToolException
+from intentkit.skills.venice_image.base import VeniceImageBaseTool
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    VeniceImageGenerationInput,
+)
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+
+class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
+    """
+    Base class for Venice AI *Image Generation* tools.
+    Inherits from VeniceAIBaseTool and handles specifics of the
+    /image/generate endpoint.
+    """
+
+    # --- Attributes specific to Image Generation ---
+    args_schema: Type[BaseModel] = VeniceImageGenerationInput
+
+    # --- Attributes Subclasses MUST Define ---
+    name: str = Field(description="The unique name of the image generation tool/model.")
+    description: str = Field(
+        description="A description of what the image generation tool/model does."
+    )
+    model_id: str = Field(
+        description="The specific model ID used in the Venice Image API call."
+    )
+
+    async def _arun(
+        self,
+        prompt: str,
+        seed: Optional[int] = None,
+        negative_prompt: Optional[str] = None,
+        width: Optional[int] = 1024,
+        height: Optional[int] = 1024,
+        format: Literal["png", "jpeg", "webp"] = "png",
+        cfg_scale: Optional[float] = 7.5,
+        style_preset: Optional[str] = "Photographic",
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        try:
+            context = self.context_from_config(config)
+            skillConfig = self.getSkillConfig(context)
+            await self.apply_venice_rate_limit(context)
+
+            final_negative_prompt = negative_prompt or skillConfig.negative_prompt
+
+            payload = {
+                "model": self.model_id,
+                "prompt": prompt,
+                "width": width,
+                "height": height,
+                "seed": seed,
+                "format": format,
+                "steps": 30,
+                "safe_mode": skillConfig.safe_mode,
+                "hide_watermark": skillConfig.hide_watermark,
+                "embed_exif_metadata": skillConfig.embed_exif_metadata,
+                "cfg_scale": cfg_scale or 7.0,
+                "style_preset": style_preset,
+                "negative_prompt": final_negative_prompt,
+                "return_binary": False,
+            }
+
+            # Strip out None values
+            payload = {k: v for k, v in payload.items() if v is not None}
+
+            result, error = await self.post("/api/v1/image/generate", payload, context)
+
+            if error:
+                raise ToolException(f"Venice Image Generation API error: {error}")
+
+            base64_image_string = result.get("images", [None])[0]
+            if not base64_image_string:
+                raise ToolException("No image data found in Venice Image API response.")
+
+            try:
+                image_bytes = base64.b64decode(base64_image_string)
+            except Exception as decode_error:
+                raise ToolException("Invalid base64 image data.") from decode_error
+
+            response_format = (
+                result.get("request", {}).get("data", {}).get("format", format)
+            )
+            file_extension = response_format or format
+            content_type = f"image/{file_extension}"
+
+            image_hash = hashlib.sha256(image_bytes).hexdigest()
+            key = f"{self.category}/{self.model_id}/{image_hash}.{file_extension}"
+
+            stored_url = await store_image_bytes(
+                image_bytes, key, content_type=content_type
+            )
+
+            # Cleanup & enrich the response
+            result.pop("images", None)
+            result["image_url"] = stored_url
+            result["image_bytes_sha256"] = image_hash
+
+            return result
+        except ToolException as e:
+            raise e
+        except Exception as e:
+            raise ToolException(
+                "An unexpected error occurred during the image generation process."
+            ) from e

intentkit/skills/venice_image/image_generation/image_generation_fluently_xl.py

@@ -0,0 +1,26 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationFluentlyXL(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using the Fluently-XL model via Venice AI.
+    Known for aesthetics, lighting, realism, and correct anatomy.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_fluently_xl"
+    description: str = (
+        "Generate images using the Fluently-XL model (via Venice AI).\n"
+        "Aims for improved aesthetics, lighting, realism, and anatomy. Good for professional-quality images.\n"
+        "Provide a text prompt describing the image (up to 1500 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 8)."
+    )
+    model_id: str = "fluently-xl"
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_generation/image_generation_flux_dev.py

@@ -0,0 +1,27 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationFluxDev(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using Venice AI's Flux Dev model.
+    Developed by Black Forest Labs, this is a 12 billion parameter rectified flow transformer.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_flux_dev"
+    description: str = (
+        "Generate images using Venice AI's Flux Dev model (by Black Forest Labs).\n"
+        "This 12B parameter model is good for research and innovative art workflows.\n"
+        "Provide a text prompt describing the image (up to 2048 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 8).\n"
+        "Use complies with FLUX.1 [dev] Non-Commercial License."
+    )
+    model_id: str = "flux-dev"
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_generation/image_generation_flux_dev_uncensored.py

@@ -0,0 +1,26 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationFluxDevUncensored(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using Venice AI's Flux Dev Uncensored model.
+    An uncensored version of the flux-dev model for unrestricted generation.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_flux_dev_uncensored"
+    description: str = (
+        "Generate images using Venice AI's Flux Dev Uncensored model.\n"
+        "This is an uncensored version of flux-dev, suitable for unrestricted content including NSFW.\n"
+        "Provide a text prompt describing the image (up to 2048 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 8)."
+    )
+    model_id: str = "flux-dev-uncensored"
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_generation/image_generation_input.py

@@ -0,0 +1,158 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field, HttpUrl
+
+STYLE_PRESETS = [
+    "3D Model",
+    "Analog Film",
+    "Anime",
+    "Cinematic",
+    "Comic Book",
+    "Craft Clay",
+    "Digital Art",
+    "Enhance",
+    "Fantasy Art",
+    "Isometric Style",
+    "Line Art",
+    "Lowpoly",
+    "Neon Punk",
+    "Origami",
+    "Photographic",
+    "Pixel Art",
+    "Texture",
+    "Advertising",
+    "Food Photography",
+    "Real Estate",
+    "Abstract",
+    "Cubist",
+    "Graffiti",
+    "Hyperrealism",
+    "Impressionist",
+    "Pointillism",
+    "Pop Art",
+    "Psychedelic",
+    "Renaissance",
+    "Steampunk",
+    "Surrealist",
+    "Typography",
+    "Watercolor",
+    "Fighting Game",
+    "GTA",
+    "Super Mario",
+    "Minecraft",
+    "Pokemon",
+    "Retro Arcade",
+    "Retro Game",
+    "RPG Fantasy Game",
+    "Strategy Game",
+    "Street Fighter",
+    "Legend of Zelda",
+    "Architectural",
+    "Disco",
+    "Dreamscape",
+    "Dystopian",
+    "Fairy Tale",
+    "Gothic",
+    "Grunge",
+    "Horror",
+    "Minimalist",
+    "Monochrome",
+    "Nautical",
+    "Space",
+    "Stained Glass",
+    "Techwear Fashion",
+    "Tribal",
+    "Zentangle",
+    "Collage",
+    "Flat Papercut",
+    "Kirigami",
+    "Paper Mache",
+    "Paper Quilling",
+    "Papercut Collage",
+    "Papercut Shadow Box",
+    "Stacked Papercut",
+    "Thick Layered Papercut",
+    "Alien",
+    "Film Noir",
+    "HDR",
+    "Long Exposure",
+    "Neon Noir",
+    "Silhouette",
+    "Tilt-Shift",
+]
+
+STYLE_PRESETS_DESCRIPTION = (
+    "Optional style preset to apply. Available options: "
+    + ", ".join([f"'{s}'" for s in STYLE_PRESETS])
+    + ". Defaults to 'Photographic'."
+)
+
+
+class InpaintMask(BaseModel):
+    image_prompt: str = Field(
+        ...,
+        description="A text prompt describing the original input image that an image model would use to produce a similar/identical image, including the changed features the user will be inpainting.",
+    )
+    inferred_object: str = Field(
+        ..., description="The content being added via inpainting."
+    )
+    object_target: str = Field(
+        ..., description="Element(s) in the original image to be inpainted over."
+    )
+
+
+class Inpaint(BaseModel):
+    image_url: HttpUrl = Field(
+        ...,
+        description="Image target to inpaint",
+    )
+    strength: int = Field(
+        ..., ge=0, le=100, description="Strength of the inpainting (0-100).", example=50
+    )
+    mask: InpaintMask = Field(..., description="Mask settings for inpainting.")
+
+
+class VeniceImageGenerationInput(BaseModel):
+    """Model representing input parameters for Venice Image Generation."""
+
+    prompt: str = Field(
+        description="The main text prompt describing what should be included in the generated image."
+    )
+    seed: Optional[int] = Field(
+        default=None,
+        description="Random seed value to control image generation randomness. "
+        "Use the same seed to reproduce identical results. If not set, a random seed will be used.",
+    )
+    negative_prompt: Optional[str] = Field(
+        default=None,
+        description="Text describing what should be excluded from the generated image. "
+        "If not provided, the default agent configuration will be used.",
+    )
+    width: Optional[int] = Field(
+        default=1024,
+        le=2048,
+        description="Width of the generated image in pixels. Maximum allowed is 2048. Default is 1024.",
+    )
+    height: Optional[int] = Field(
+        default=1024,
+        le=2048,
+        description="Height of the generated image in pixels. Maximum allowed is 2048. Default is 1024.",
+    )
+    format: Literal["png", "jpeg", "webp"] = Field(
+        default="png",
+        description="Output image format. Options are 'png', 'jpeg', or 'webp'. Defaults to 'png'.",
+    )
+    cfg_scale: Optional[float] = Field(
+        default=7.5,
+        description="Classifier-Free Guidance (CFG) scale controls how closely the image follows the prompt. "
+        "Higher values (1-20) result in more adherence. Default is 7.5.",
+    )
+    style_preset: Optional[str] = Field(
+        default="Photographic", description=STYLE_PRESETS_DESCRIPTION
+    )
+    inpainting: Optional[Inpaint] = Field(
+        default=None,
+        description="Optional inpainting operation that allows modification of specific objects within an image. "
+        "Requires an original image url, a strength value (0-100), and detailed mask instructions "
+        "to define which part of the image should be edited and what should replace it.",
+    )

intentkit/skills/venice_image/image_generation/image_generation_lustify_sdxl.py

@@ -0,0 +1,26 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationLustifySDXL(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using the Lustify SDXL model via Venice AI.
+    A photorealistic SDXL checkpoint primarily focused on NSFW content, but can do SFW.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_lustify_sdxl"
+    description: str = (
+        "Generate images using the Lustify SDXL model (via Venice AI).\n"
+        "A photorealistic SDXL model focused on NSFW scenes, but can generate SFW images (objects, animals, fantasy).\n"
+        "Provide a text prompt describing the image (up to 1500 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 8)."
+    )
+    model_id: str = "lustify-sdxl"
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_generation/image_generation_pony_realism.py

@@ -0,0 +1,26 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationPonyRealism(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using the Pony Realism model via Venice AI.
+    Focused on high-detail, realistic images, especially anime/character designs. Uses Danbooru tags.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_pony_realism"
+    description: str = (
+        "Generate images using the Pony Realism model (via Venice AI).\n"
+        "Creates high-detail, realistic images, good for anime/character designs. Benefits from Danbooru tags (e.g., 'score_9', 'female'/'male').\n"
+        "Provide a text prompt describing the image (up to 1500 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 8). Marked as 'most_uncensored'."
+    )
+    model_id: str = "pony-realism"
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_generation/image_generation_stable_diffusion_3_5.py

@@ -0,0 +1,28 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationStableDiffusion35(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using Venice AI's interface to Stable Diffusion 3.5 Large (alternative ID).
+    Developed by Stability AI, using MMDiT architecture. Good for art and design.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_stable_diffusion_3_5"  # Different skill name
+    description: str = (
+        "Generate images using Stability AI's Stable Diffusion 3.5 Large model (alternative ID via Venice AI).\n"
+        "Ideal for artworks, design processes, and educational use. Not for factual representations.\n"
+        "Provide a text prompt describing the image (up to 1500 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 16).\n"
+        "Use must comply with Stability AI's Acceptable Use Policy."
+    )
+    # Use the specific ID provided by Venice
+    model_id: str = "stable-diffusion-3.5"  # Different model ID
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_generation/image_generation_venice_sd35.py

@@ -0,0 +1,28 @@
+from intentkit.skills.venice_image.image_generation.image_generation_base import (
+    VeniceImageGenerationBaseTool,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    STYLE_PRESETS,
+)
+
+
+class ImageGenerationVeniceSD35(VeniceImageGenerationBaseTool):
+    """
+    Tool for generating images using Venice AI's interface to Stable Diffusion 3.5 Large.
+    Developed by Stability AI, using MMDiT architecture. Good for art and design.
+    """
+
+    # --- Model Specific Configuration ---
+    name: str = "venice_image_generation_venice_sd35"
+    description: str = (
+        "Generate images using Stability AI's Stable Diffusion 3.5 Large model (via Venice AI).\n"
+        "Ideal for artworks, design processes, and educational use. Not for factual representations.\n"
+        "Provide a text prompt describing the image (up to 1500 chars).\n"
+        f"Optionally specify a style preset from the list: {', '.join(STYLE_PRESETS)}.\n"
+        "Supports dimensions up to 2048x2048 (multiple of 16).\n"
+        "Use must comply with Stability AI's Acceptable Use Policy."
+    )
+    # Use the specific ID provided by Venice, assuming it matches the name
+    model_id: str = "venice-sd35"
+
+    # args_schema and _arun are inherited from VeniceImageGenerationBaseTool

intentkit/skills/venice_image/image_upscale/README.md

@@ -0,0 +1,111 @@
+# image_upscale
+
+**Image Upscale** is a sub-tool of the Venice Image suite. It uses Venice AI’s powerful super-resolution models to increase the size and clarity of images by 2x or 4x, making low-resolution images suitable for HD displays, print, or content enhancement. This is not just simple pixel stretching—it uses AI to intelligently recreate additional detail, texture, and smoothness.
+
+---
+
+## What does it do?
+
+Given any publicly accessible image URL, the tool fetches the image, applies deep-learning upscaling (super-resolution), and returns a new image URL to the upscaled output. Users can choose between 2x or 4x upscaling depending on needs, and can optionally control how much "realism"/texture is preserved from the original.
+
+Key benefits:
+- Consistent color, sharpness, and clarity at higher resolutions
+- AI removes pixelation and can reduce compression artifacts
+- Optional "replication" factor lets you tune how much of the original’s noise/detail is restored
+
+---
+
+## Input
+
+| Field        | Type             | Description                                                                                          | Required | Default |
+|--------------|------------------|------------------------------------------------------------------------------------------------------|----------|---------|
+| image_url    | HttpUrl          | Public URL to the image you want to upscale.                                                         | Yes      |         |
+| scale        | Literal[2, 4]    | The scaling factor (2 for 2x, 4 for 4x enlargement).                                                 | Yes      | 2       |
+| replication  | float (0.1–1.0)  | How much to preserve edges, texture, and noise from original (higher = more detail, less smoothing). | No       | 0.35    |
+
+Example:
+```json
+{
+  "image_url": "https://example.com/photo.jpg",
+  "scale": 4,
+  "replication": 0.5
+}
+```
+
+---
+
+## Output
+
+On success, returns a result dictionary containing at least:
+- `success`: true
+- `result`: URL for the upscaled image (typically hosted on S3 or compatible object storage)
+- Additional metadata as needed
+
+Example:
+```json
+{
+  "success": true,
+  "result": "https://s3.storage.example/venice_image/image_upscale/1a2b3c....png"
+}
+```
+
+On error:
+```json
+{
+  "success": false,
+  "error": "Failed to fetch or validate image from URL: ...",
+  "result": null
+}
+```
+
+---
+
+## Typical Use Cases
+
+- **Photo Restoration** – Upscale old, small web images for print or display
+- **Content Creation** – Create HD assets from AI-generated or web-ripped images
+- **Design/Prototyping** – Improve source assets for posters, presentations, or large canvas
+- **Archival** – Enhance legacy digital art or research scans
+
+---
+
+## Advanced Notes
+
+- Works for all common raster formats (JPG, PNG, WEBP). Unsupported types are auto-converted to PNG.
+- "Replication" factor explanation:
+  - **Low values (e.g., 0.1–0.25):** smoother, less noise, more “plastic” look (good for AI/clean results)
+  - **High values (e.g., 0.7–1.0):** preserves original photo noise/texture, less smoothing (good for art/photo upscaling)
+- Original aspect ratio is always preserved.
+
+---
+
+## Limitations
+
+- Does not add content—only increases fidelity of existing features.
+- Output detail is limited by source image quality and AI model limits.
+- NSFW images will be blurred if safe mode is enabled.
+
+---
+
+## Example Usage (Pseudo-code)
+
+```python
+result = await agent.send_tool(
+    "image_upscale",
+    {
+        "image_url": "https://somehost.com/image.png",
+        "scale": 2,
+        "replication": 0.4
+    }
+)
+upscaled_url = result["result"]
+```
+
+---
+
+## Compliance & Attribution
+
+- You must have rights to use the supplied image.
+- Follows [Venice AI terms of service](https://venice.ai/).
+
+---

intentkit/skills/venice_image/image_upscale/image_upscale.py

@@ -0,0 +1,90 @@
+import logging
+from typing import Literal, Optional
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import HttpUrl
+
+from intentkit.skills.base import ToolException
+from intentkit.skills.venice_image.image_upscale.image_upscale_base import (
+    VeniceImageUpscaleBaseTool,
+)
+from intentkit.skills.venice_image.utils import fetch_image_as_base64
+
+logger = logging.getLogger(__name__)
+
+
+class ImageUpscale(VeniceImageUpscaleBaseTool):
+    """
+    Upscales an existing image provided via URL by a factor of 2 or 4 using the Venice AI API.
+    Ideal for enhancing the resolution of previously generated or existing images.
+    """
+
+    # --- Tool Specific Configuration ---
+    name: str = "venice_image_upscale"
+    description: str = (
+        "Upscales an existing image from a URL using Venice AI.\n"
+        "Provide the public URL of the image to upscale.\n"
+        "Specify the desired scale factor: 2 (for 2x upscale) or 4 (for 4x upscale).\n"
+        "Returns the URL of the upscaled image."
+    )
+
+    # No model_id needed for the generic upscale endpoint currently
+    async def _arun(
+        self,
+        image_url: HttpUrl,
+        scale: Literal[2, 4],
+        replication: Optional[float] = 0.35,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> dict:
+        """
+        Asynchronously upscales an image from the provided URL using the Venice AI API.
+
+        Args:
+            image_url (HttpUrl): The public URL of the image to upscale.
+            scale (Literal[2, 4]): The scale factor for upscaling (2x or 4x).
+            replication (Optional[float]): The replication factor for the upscale process, defaults to 0.35.
+            config (RunnableConfig, optional): Configuration for the runnable, if any.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            dict: The API response containing the URL of the upscaled image.
+
+        Raises:
+            ToolException: If the image cannot be fetched, validated, or upscaled, or if an API error occurs.
+        """
+
+        try:
+            context = self.context_from_config(config)
+
+            await self.apply_venice_rate_limit(context)
+
+            image_base64 = await fetch_image_as_base64(image_url)
+            if not image_base64:
+                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
+                logger.error(error_msg)
+                raise ToolException(
+                    str({"success": False, "error": error_msg, "result": None})
+                )
+
+            payload = {
+                "image": image_base64,
+                "scale": scale,
+                "replication": replication,
+            }
+            result, error = await self.post("api/v1/image/upscale", payload, context)
+            if error:
+                raise ToolException(f"Venice Image Upscale API error: {error}")
+            return result
+        except ToolException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error in {self.name}: {str(e)}")
+            raise ToolException(
+                str(
+                    {
+                        "success": False,
+                        "error": f"An unexpected error occurred: {str(e)}",
+                    }
+                )
+            )