intentkit 0.8.16.dev1__py3-none-any.whl → 0.8.17.dev2__py3-none-any.whl

intentkit/skills/venice_image/api.py

@@ -1,138 +1,138 @@
-"""
-This module encapsulates all interactions with the Venice AI API.
-It provides a function, make_venice_api_request, to make POST requests
-to the API and handles the responses, including error handling,
-content type checking, and image storage via S3.  This separation
-of concerns keeps the core skill logic cleaner and easier to maintain.
-"""
-
-import hashlib
-import logging
-from typing import Any, Dict, Optional, Tuple
-
-import httpx
-
-from intentkit.utils.s3 import store_image_bytes
-
-logger = logging.getLogger(__name__)
-
-
-async def make_venice_api_request(
-    api_key: str,
-    path: str,
-    payload: Dict[str, Any],
-    category: str,
-    tool_name: str,
-) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-    """
-    Makes a POST request to the Venice AI API, handling all aspects
-    of the API interaction.  This includes:
-
-    1.  Constructing the API URL using a base URL and the provided path.
-    2.  Adding the required authorization header with the provided API key.
-    3.  Sending the POST request with the given payload.
-    4.  Handling potential connection and HTTP errors.
-    5.  Calling the internal _handle_response function to process the API's
-        response, which might be JSON or an image.
-
-    Args:
-        api_key: The Venice AI API key for authentication.
-        path: The API endpoint path (e.g., "/api/v1/image/generate").  Should *not* start with the base URL.
-        payload: The data to send in the request body (as JSON).
-        category: The category of the skill making the request (e.g., "venice_image"). Used for S3 storage and logging purpose.
-        tool_name: The name of the tool or skill making the request (e.g., "image_generation"). Used for S3 storage and logging purpose.
-
-    Returns:
-        A tuple: (success_data, error_data).
-        - success_data:  A dictionary containing the parsed JSON response from the API if the request was successful
-          (or a dictionary containing the S3 URL if the response is an image).
-        - error_data:  A dictionary containing information about any errors that occurred,
-          or None if the request was successful.  The dictionary includes an 'error' key.
-    """
-
-    venice_base_url = "https://api.venice.ai"  # Venice AI API base URL
-
-    if not path.startswith("/"):
-        path = "/" + path
-
-    api_url = f"{venice_base_url}{path}"
-
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-        "Accept": "image/*, application/json",
-    }
-
-    logger.info(
-        f"[{category}/{tool_name}] Sending request to {api_url} with payload: {payload}"
-    )
-
-    try:
-        async with httpx.AsyncClient(timeout=180.0) as client:
-            response = await client.post(api_url, json=payload, headers=headers)
-            return await _handle_response(response, category, tool_name)
-
-    except httpx.RequestError as e:
-        error_msg = f"Connection error: {e}"
-        logger.error(f"[{category}/{tool_name}] {error_msg}")
-        return {}, {"success": False, "error": error_msg}
-    except Exception as e:
-        error_msg = f"Unexpected error: {e}"
-        logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
-        return {}, {"success": False, "error": error_msg}
-
-
-async def _handle_response(
-    response: httpx.Response, category: str, tool_name: str
-) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-    """
-    Handles the API response, differentiating between JSON and image responses.
-
-    If the response is an image (based on the 'content-type' header),
-    it stores the image in S3 and returns the S3 URL.
-    If the response is JSON, it parses the JSON and returns it.
-    If any errors occur, it returns an error dictionary.
-    """
-
-    content_type = str(response.headers.get("content-type", "")).lower()
-
-    if response.status_code == 200 and content_type.startswith("image/"):
-        try:
-            upscaled_image_bytes = response.content
-            image_hash = hashlib.sha256(upscaled_image_bytes).hexdigest()
-            file_extension = content_type.split("/")[-1].split("+")[0] or "png"
-
-            key = f"{category}/{tool_name}/{image_hash}.{file_extension}"
-
-            logger.info(f"[{category}/{tool_name}] Storing image with key: {key}")
-
-            stored_url = await store_image_bytes(
-                upscaled_image_bytes, key, content_type=content_type
-            )
-
-            return {"success": True, "result": stored_url}, None
-
-        except Exception as e:
-            error_msg = f"Error processing image response: {e}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
-            return {}, {"success": False, "error": error_msg}
-
-    elif response.status_code == 200:
-        try:
-            logger.info(f"[{category}/{tool_name}] Received successful JSON response.")
-            return response.json(), None
-        except Exception as json_err:
-            error_msg = f"Failed to parse JSON response: {json_err} - {response.text}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}")
-            return {}, {"success": False, "error": error_msg}
-
-    else:
-        try:
-            error_data = response.json()
-            error_msg = f"API returned error: {error_data.get('message', error_data.get('detail', response.text))}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}")
-            return {}, {"success": False, "error": error_msg}
-        except Exception:
-            error_msg = f"API returned status code {response.status_code} with text: {response.text}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}")
-            return {}, {"success": False, "error": error_msg}
+"""
+This module encapsulates all interactions with the Venice AI API.
+It provides a function, make_venice_api_request, to make POST requests
+to the API and handles the responses, including error handling,
+content type checking, and image storage via S3.  This separation
+of concerns keeps the core skill logic cleaner and easier to maintain.
+"""
+
+import hashlib
+import logging
+from typing import Any
+
+import httpx
+
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+
+async def make_venice_api_request(
+    api_key: str,
+    path: str,
+    payload: dict[str, Any],
+    category: str,
+    tool_name: str,
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    """
+    Makes a POST request to the Venice AI API, handling all aspects
+    of the API interaction.  This includes:
+
+    1.  Constructing the API URL using a base URL and the provided path.
+    2.  Adding the required authorization header with the provided API key.
+    3.  Sending the POST request with the given payload.
+    4.  Handling potential connection and HTTP errors.
+    5.  Calling the internal _handle_response function to process the API's
+        response, which might be JSON or an image.
+
+    Args:
+        api_key: The Venice AI API key for authentication.
+        path: The API endpoint path (e.g., "/api/v1/image/generate").  Should *not* start with the base URL.
+        payload: The data to send in the request body (as JSON).
+        category: The category of the skill making the request (e.g., "venice_image"). Used for S3 storage and logging purpose.
+        tool_name: The name of the tool or skill making the request (e.g., "image_generation"). Used for S3 storage and logging purpose.
+
+    Returns:
+        A tuple: (success_data, error_data).
+        - success_data:  A dictionary containing the parsed JSON response from the API if the request was successful
+          (or a dictionary containing the S3 URL if the response is an image).
+        - error_data:  A dictionary containing information about any errors that occurred,
+          or None if the request was successful.  The dictionary includes an 'error' key.
+    """
+
+    venice_base_url = "https://api.venice.ai"  # Venice AI API base URL
+
+    if not path.startswith("/"):
+        path = "/" + path
+
+    api_url = f"{venice_base_url}{path}"
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "Accept": "image/*, application/json",
+    }
+
+    logger.info(
+        f"[{category}/{tool_name}] Sending request to {api_url} with payload: {payload}"
+    )
+
+    try:
+        async with httpx.AsyncClient(timeout=180.0) as client:
+            response = await client.post(api_url, json=payload, headers=headers)
+            return await _handle_response(response, category, tool_name)
+
+    except httpx.RequestError as e:
+        error_msg = f"Connection error: {e}"
+        logger.error(f"[{category}/{tool_name}] {error_msg}")
+        return {}, {"success": False, "error": error_msg}
+    except Exception as e:
+        error_msg = f"Unexpected error: {e}"
+        logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
+        return {}, {"success": False, "error": error_msg}
+
+
+async def _handle_response(
+    response: httpx.Response, category: str, tool_name: str
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    """
+    Handles the API response, differentiating between JSON and image responses.
+
+    If the response is an image (based on the 'content-type' header),
+    it stores the image in S3 and returns the S3 URL.
+    If the response is JSON, it parses the JSON and returns it.
+    If any errors occur, it returns an error dictionary.
+    """
+
+    content_type = str(response.headers.get("content-type", "")).lower()
+
+    if response.status_code == 200 and content_type.startswith("image/"):
+        try:
+            upscaled_image_bytes = response.content
+            image_hash = hashlib.sha256(upscaled_image_bytes).hexdigest()
+            file_extension = content_type.split("/")[-1].split("+")[0] or "png"
+
+            key = f"{category}/{tool_name}/{image_hash}.{file_extension}"
+
+            logger.info(f"[{category}/{tool_name}] Storing image with key: {key}")
+
+            stored_url = await store_image_bytes(
+                upscaled_image_bytes, key, content_type=content_type
+            )
+
+            return {"success": True, "result": stored_url}, None
+
+        except Exception as e:
+            error_msg = f"Error processing image response: {e}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
+            return {}, {"success": False, "error": error_msg}
+
+    elif response.status_code == 200:
+        try:
+            logger.info(f"[{category}/{tool_name}] Received successful JSON response.")
+            return response.json(), None
+        except Exception as json_err:
+            error_msg = f"Failed to parse JSON response: {json_err} - {response.text}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}")
+            return {}, {"success": False, "error": error_msg}
+
+    else:
+        try:
+            error_data = response.json()
+            error_msg = f"API returned error: {error_data.get('message', error_data.get('detail', response.text))}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}")
+            return {}, {"success": False, "error": error_msg}
+        except Exception:
+            error_msg = f"API returned status code {response.status_code} with text: {response.text}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}")
+            return {}, {"success": False, "error": error_msg}

intentkit/skills/venice_image/base.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, Optional, Tuple
+from typing import Any
 
 from langchain_core.tools.base import ToolException
 
@@ -155,8 +155,8 @@ class VeniceImageBaseTool(IntentKitSkill):
             raise ToolException(f"Failed to apply Venice rate limit: {str(e)}") from e
 
     async def post(
-        self, path: str, payload: Dict[str, Any], context
-    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+        self, path: str, payload: dict[str, Any], context
+    ) -> tuple[dict[str, Any], dict[str, Any] | None]:
         """
         Makes a POST request to the Venice AI API using the `make_venice_api_request`
         function from the `skills.venice_image.api` module.

intentkit/skills/venice_image/config.py

@@ -1,35 +1,33 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class VeniceImageConfig(BaseModel):
-    """Skill Config for Venice Image."""
-
-    api_key_provider: str = Field(
-        default="agent_owner",
-        description="Provider of the API Key, could be agent_owner or platform",
-    )
-    safe_mode: bool = Field(
-        default=True,
-        description="Whether to use safe mode. If enabled, this will blur images that are classified as having adult content",
-    )
-    hide_watermark: bool = Field(
-        default=True,
-        description="Whether to hide the Venice watermark. Venice may ignore this parameter for certain generated content.",
-    )
-    embed_exif_metadata: bool = Field(
-        default=False, description="Whether to embed EXIF metadata in the image."
-    )
-    negative_prompt: str = Field(
-        default="(worst quality: 1.4), bad quality, nsfw",
-        description="The default negative prompt used when no other prompt is provided.",
-    )
-    rate_limit_number: Optional[int] = Field(
-        default=None,
-        description="Maximum number of allowed calls within the specified time window.",
-    )
-    rate_limit_minutes: Optional[int] = Field(
-        default=None,
-        description="Duration of the time window (in minutes) for rate limiting.",
-    )
+from pydantic import BaseModel, Field
+
+
+class VeniceImageConfig(BaseModel):
+    """Skill Config for Venice Image."""
+
+    api_key_provider: str = Field(
+        default="agent_owner",
+        description="Provider of the API Key, could be agent_owner or platform",
+    )
+    safe_mode: bool = Field(
+        default=True,
+        description="Whether to use safe mode. If enabled, this will blur images that are classified as having adult content",
+    )
+    hide_watermark: bool = Field(
+        default=True,
+        description="Whether to hide the Venice watermark. Venice may ignore this parameter for certain generated content.",
+    )
+    embed_exif_metadata: bool = Field(
+        default=False, description="Whether to embed EXIF metadata in the image."
+    )
+    negative_prompt: str = Field(
+        default="(worst quality: 1.4), bad quality, nsfw",
+        description="The default negative prompt used when no other prompt is provided.",
+    )
+    rate_limit_number: int | None = Field(
+        default=None,
+        description="Maximum number of allowed calls within the specified time window.",
+    )
+    rate_limit_minutes: int | None = Field(
+        default=None,
+        description="Duration of the time window (in minutes) for rate limiting.",
+    )

intentkit/skills/venice_image/image_enhance/image_enhance.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from pydantic import HttpUrl
 
@@ -30,8 +29,8 @@ class ImageEnhance(VeniceImageEnhanceBaseTool):
         self,
         image_url: HttpUrl,
         enhancePrompt: str,
-        replication: Optional[float] = 0.35,
-        enhanceCreativity: Optional[float] = 0.5,
+        replication: float | None = 0.35,
+        enhanceCreativity: float | None = 0.5,
         **kwargs,
     ) -> dict:
         """

intentkit/skills/venice_image/image_enhance/image_enhance_base.py

@@ -1,23 +1,21 @@
-from typing import Type
-
-from pydantic import BaseModel, Field
-
-# Import the generic base and shared input
-from intentkit.skills.venice_image.base import VeniceImageBaseTool
-from intentkit.skills.venice_image.image_enhance.image_enhance_input import (
-    VeniceImageEnhanceInput,
-)
-
-
-class VeniceImageEnhanceBaseTool(VeniceImageBaseTool):
-    """
-    Base class for Venice AI *Image Enchanching* tools.
-    Inherits from VeniceAIBaseTool and handles specifics of the
-    /image/upscale endpoint
-    """
-
-    args_schema: Type[BaseModel] = VeniceImageEnhanceInput
-    name: str = Field(description="The unique name of the image Enchanching tool.")
-    description: str = Field(
-        description="A description of what the image Enchanching tool does."
-    )
+from pydantic import BaseModel, Field
+
+# Import the generic base and shared input
+from intentkit.skills.venice_image.base import VeniceImageBaseTool
+from intentkit.skills.venice_image.image_enhance.image_enhance_input import (
+    VeniceImageEnhanceInput,
+)
+
+
+class VeniceImageEnhanceBaseTool(VeniceImageBaseTool):
+    """
+    Base class for Venice AI *Image Enchanching* tools.
+    Inherits from VeniceAIBaseTool and handles specifics of the
+    /image/upscale endpoint
+    """
+
+    args_schema: type[BaseModel] = VeniceImageEnhanceInput
+    name: str = Field(description="The unique name of the image Enchanching tool.")
+    description: str = Field(
+        description="A description of what the image Enchanching tool does."
+    )

intentkit/skills/venice_image/image_enhance/image_enhance_input.py

@@ -1,40 +1,38 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class VeniceImageEnhanceInput(BaseModel):
-    """Input for Venice Image Enhance tool (scale=1, enhance=True)."""
-
-    image_url: str = Field(
-        description="The URL of the image to enhance. Must be a publicly accessible URL."
-    )
-
-    enhancePrompt: str = Field(
-        ...,
-        max_length=1500,
-        description=(
-            "Required prompt describing the desired enhancement style. "
-            "Best used with short descriptors like 'gold', 'marble', or 'angry, menacing'."
-        ),
-    )
-
-    replication: Optional[float] = Field(
-        default=0.35,
-        ge=0.1,
-        le=1.0,
-        description=(
-            "How strongly lines and noise in the base image are preserved. "
-            "Higher values retain more noise and detail but are less smooth."
-        ),
-    )
-
-    enhanceCreativity: float = Field(
-        default=0.5,
-        ge=0.0,
-        le=1.0,
-        description=(
-            "How much the enhancement AI is allowed to change the image. "
-            "0 = minimal change, 1 = generate a new image entirely."
-        ),
-    )
+from pydantic import BaseModel, Field
+
+
+class VeniceImageEnhanceInput(BaseModel):
+    """Input for Venice Image Enhance tool (scale=1, enhance=True)."""
+
+    image_url: str = Field(
+        description="The URL of the image to enhance. Must be a publicly accessible URL."
+    )
+
+    enhancePrompt: str = Field(
+        ...,
+        max_length=1500,
+        description=(
+            "Required prompt describing the desired enhancement style. "
+            "Best used with short descriptors like 'gold', 'marble', or 'angry, menacing'."
+        ),
+    )
+
+    replication: float | None = Field(
+        default=0.35,
+        ge=0.1,
+        le=1.0,
+        description=(
+            "How strongly lines and noise in the base image are preserved. "
+            "Higher values retain more noise and detail but are less smooth."
+        ),
+    )
+
+    enhanceCreativity: float = Field(
+        default=0.5,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "How much the enhancement AI is allowed to change the image. "
+            "0 = minimal change, 1 = generate a new image entirely."
+        ),
+    )

intentkit/skills/venice_image/image_generation/image_generation_base.py

@@ -1,7 +1,7 @@
 import base64
 import hashlib
 import logging
-from typing import Any, Dict, Literal, Optional, Type
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field
 
@@ -24,7 +24,7 @@ class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
     """
 
     # --- Attributes specific to Image Generation ---
-    args_schema: Type[BaseModel] = VeniceImageGenerationInput
+    args_schema: type[BaseModel] = VeniceImageGenerationInput
 
     # --- Attributes Subclasses MUST Define ---
     name: str = Field(description="The unique name of the image generation tool/model.")
@@ -38,15 +38,15 @@ class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
     async def _arun(
         self,
         prompt: str,
-        seed: Optional[int] = None,
-        negative_prompt: Optional[str] = None,
-        width: Optional[int] = 1024,
-        height: Optional[int] = 1024,
+        seed: int | None = None,
+        negative_prompt: str | None = None,
+        width: int | None = 1024,
+        height: int | None = 1024,
         format: Literal["png", "jpeg", "webp"] = "png",
-        cfg_scale: Optional[float] = 7.5,
-        style_preset: Optional[str] = "Photographic",
+        cfg_scale: float | None = 7.5,
+        style_preset: str | None = "Photographic",
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         try:
             context = self.get_context()
             skillConfig = self.getSkillConfig(context)

intentkit/skills/venice_image/image_generation/image_generation_fluently_xl.py

@@ -1,26 +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
+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