intentkit 0.7.5.dev18__py3-none-any.whl → 0.7.5.dev19__py3-none-any.whl

intentkit/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.7.5-dev18"
+__version__ = "0.7.5-dev19"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/abstracts/graph.py

@@ -1,6 +1,5 @@
-import asyncio
 from enum import Enum
-from typing import Any, Dict, NotRequired, Optional
+from typing import Any, Callable, Dict, NotRequired, Optional
 
 from langgraph.prebuilt.chat_agent_executor import AgentState as BaseAgentState
 from pydantic import BaseModel
@@ -29,6 +28,7 @@ class AgentState(BaseAgentState):
 
 class AgentContext(BaseModel):
     agent_id: str
+    get_agent: Callable[[], Agent]
     chat_id: str
     user_id: Optional[str] = None
     app_id: Optional[str] = None
@@ -38,4 +38,4 @@ class AgentContext(BaseModel):
 
     @property
     def agent(self) -> Agent:
-        return asyncio.run(Agent.get(self.agent_id))
+        return self.get_agent()

intentkit/core/engine.py

@@ -65,11 +65,9 @@ logger = logging.getLogger(__name__)
 
 # Global variable to cache all agent executors
 _agents: dict[str, CompiledStateGraph] = {}
-_private_agents: dict[str, CompiledStateGraph] = {}
 
 # Global dictionaries to cache agent update times
 _agents_updated: dict[str, datetime] = {}
-_private_agents_updated: dict[str, datetime] = {}
 
 
 async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph:
@@ -279,24 +277,30 @@ async def stream_agent(message: ChatMessageCreate):
     Yields:
         ChatMessage: Individual response messages including timing information
     """
+    agent = await Agent.get(message.agent_id)
+    executor, cold_start_cost = await agent_executor(message.agent_id)
+    message.cold_start_cost = cold_start_cost
+    async for chat_message in stream_agent_raw(message, agent, executor):
+        yield chat_message
+
+
+async def stream_agent_raw(
+    message: ChatMessageCreate, agent: Agent, executor: CompiledStateGraph
+):
     start = time.perf_counter()
     # make sure reply_to is set
     message.reply_to = message.id
 
     # save input message first
-    input = await message.save()
+    user_message = await message.save()
 
-    # agent
-    agent = await Agent.get(input.agent_id)
-
-    # model
     model = await LLMModelInfo.get(agent.model)
 
     payment_enabled = config.payment_enabled
 
     # check user balance
     if payment_enabled:
-        if not input.user_id or not agent.owner:
+        if not user_message.user_id or not agent.owner:
             raise IntentKitAPIError(
                 500,
                 "PaymentError",
@@ -307,20 +311,20 @@ async def stream_agent(message: ChatMessageCreate):
             if owner and agent.fee_percentage > 100 + owner.nft_count * 10:
                 error_message_create = await ChatMessageCreate.from_system_message(
                     SystemMessageType.SERVICE_FEE_ERROR,
-                    agent_id=input.agent_id,
-                    chat_id=input.chat_id,
-                    user_id=input.user_id,
-                    author_id=input.agent_id,
-                    thread_type=input.author_type,
-                    reply_to=input.id,
+                    agent_id=user_message.agent_id,
+                    chat_id=user_message.chat_id,
+                    user_id=user_message.user_id,
+                    author_id=user_message.agent_id,
+                    thread_type=user_message.author_type,
+                    reply_to=user_message.id,
                     time_cost=time.perf_counter() - start,
                 )
                 error_message = await error_message_create.save()
                 yield error_message
                 return
         # payer
-        payer = input.user_id
-        if input.author_type in [
+        payer = user_message.user_id
+        if user_message.author_type in [
             AuthorType.TELEGRAM,
             AuthorType.TWITTER,
             AuthorType.API,
@@ -343,12 +347,12 @@ async def stream_agent(message: ChatMessageCreate):
             if quota and quota.free_income_daily > 24000:
                 error_message_create = await ChatMessageCreate.from_system_message(
                     SystemMessageType.DAILY_USAGE_LIMIT_EXCEEDED,
-                    agent_id=input.agent_id,
-                    chat_id=input.chat_id,
-                    user_id=input.user_id,
-                    author_id=input.agent_id,
-                    thread_type=input.author_type,
-                    reply_to=input.id,
+                    agent_id=user_message.agent_id,
+                    chat_id=user_message.chat_id,
+                    user_id=user_message.user_id,
+                    author_id=user_message.agent_id,
+                    thread_type=user_message.author_type,
+                    reply_to=user_message.id,
                     time_cost=time.perf_counter() - start,
                 )
                 error_message = await error_message_create.save()
@@ -361,12 +365,12 @@ async def stream_agent(message: ChatMessageCreate):
         if not user_account.has_sufficient_credits(avg_count):
             error_message_create = await ChatMessageCreate.from_system_message(
                 SystemMessageType.INSUFFICIENT_BALANCE,
-                agent_id=input.agent_id,
-                chat_id=input.chat_id,
-                user_id=input.user_id,
-                author_id=input.agent_id,
-                thread_type=input.author_type,
-                reply_to=input.id,
+                agent_id=user_message.agent_id,
+                chat_id=user_message.chat_id,
+                user_id=user_message.user_id,
+                author_id=user_message.agent_id,
+                thread_type=user_message.author_type,
+                reply_to=user_message.id,
                 time_cost=time.perf_counter() - start,
             )
             error_message = await error_message_create.save()
@@ -374,23 +378,22 @@ async def stream_agent(message: ChatMessageCreate):
             return
 
     is_private = False
-    if input.user_id == agent.owner:
+    if user_message.user_id == agent.owner:
         is_private = True
 
-    executor, cold_start_cost = await agent_executor(input.agent_id)
-    last = start + cold_start_cost
+    last = start
 
     # Extract images from attachments
     image_urls = []
-    if input.attachments:
+    if user_message.attachments:
         image_urls = [
             att["url"]
-            for att in input.attachments
+            for att in user_message.attachments
             if "type" in att and att["type"] == "image" and "url" in att
         ]
 
     # Process input message to handle @skill patterns
-    input_message = await explain_prompt(input.message)
+    input_message = await explain_prompt(user_message.message)
 
     # super mode
     recursion_limit = 30
@@ -446,7 +449,7 @@ async def stream_agent(message: ChatMessageCreate):
     ]
 
     # stream config
-    thread_id = f"{input.agent_id}-{input.chat_id}"
+    thread_id = f"{user_message.agent_id}-{user_message.chat_id}"
     stream_config = {
         "configurable": {
             "thread_id": thread_id,
@@ -454,12 +457,16 @@ async def stream_agent(message: ChatMessageCreate):
         "recursion_limit": recursion_limit,
     }
 
+    def get_agent() -> Agent:
+        return agent
+
     context = AgentContext(
-        agent_id=input.agent_id,
-        chat_id=input.chat_id,
-        user_id=input.user_id,
-        app_id=input.app_id,
-        entrypoint=input.author_type,
+        agent_id=user_message.agent_id,
+        get_agent=get_agent,
+        chat_id=user_message.chat_id,
+        user_id=user_message.user_id,
+        app_id=user_message.app_id,
+        entrypoint=user_message.author_type,
         is_private=is_private,
         payer=payer if payment_enabled else None,
     )
@@ -496,14 +503,14 @@ async def stream_agent(message: ChatMessageCreate):
                     # agent message
                     chat_message_create = ChatMessageCreate(
                         id=str(XID()),
-                        agent_id=input.agent_id,
-                        chat_id=input.chat_id,
-                        user_id=input.user_id,
-                        author_id=input.agent_id,
+                        agent_id=user_message.agent_id,
+                        chat_id=user_message.chat_id,
+                        user_id=user_message.user_id,
+                        author_id=user_message.agent_id,
                         author_type=AuthorType.AGENT,
                         model=agent.model,
-                        thread_type=input.author_type,
-                        reply_to=input.id,
+                        thread_type=user_message.author_type,
+                        reply_to=user_message.id,
                         message=content,
                         input_tokens=(
                             msg.usage_metadata.get("input_tokens", 0)
@@ -518,9 +525,6 @@ async def stream_agent(message: ChatMessageCreate):
                         time_cost=this_time - last,
                     )
                     last = this_time
-                    if cold_start_cost > 0:
-                        chat_message_create.cold_start_cost = cold_start_cost
-                        cold_start_cost = 0
                     # handle message and payment in one transaction
                     async with get_session() as session:
                         # payment
@@ -541,7 +545,7 @@ async def stream_agent(message: ChatMessageCreate):
                                 for tool_output in tool_outputs:
                                     if tool_output.get("type") == "web_search_call":
                                         logger.info(
-                                            f"[{input.agent_id}] Found web_search_call in additional_kwargs"
+                                            f"[{user_message.agent_id}] Found web_search_call in additional_kwargs"
                                         )
                                         amount += 35
                                         break
@@ -549,11 +553,13 @@ async def stream_agent(message: ChatMessageCreate):
                                 session,
                                 payer,
                                 chat_message_create.id,
-                                input.id,
+                                user_message.id,
                                 amount,
                                 agent,
                             )
-                            logger.info(f"[{input.agent_id}] expense message: {amount}")
+                            logger.info(
+                                f"[{user_message.agent_id}] expense message: {amount}"
+                            )
                             chat_message_create.credit_event_id = credit_event.id
                             chat_message_create.credit_cost = credit_event.total_amount
                         chat_message = await chat_message_create.save_in_session(
@@ -604,14 +610,14 @@ async def stream_agent(message: ChatMessageCreate):
                             break
                 skill_message_create = ChatMessageCreate(
                     id=str(XID()),
-                    agent_id=input.agent_id,
-                    chat_id=input.chat_id,
-                    user_id=input.user_id,
-                    author_id=input.agent_id,
+                    agent_id=user_message.agent_id,
+                    chat_id=user_message.chat_id,
+                    user_id=user_message.user_id,
+                    author_id=user_message.agent_id,
                     author_type=AuthorType.SKILL,
                     model=agent.model,
-                    thread_type=input.author_type,
-                    reply_to=input.id,
+                    thread_type=user_message.author_type,
+                    reply_to=user_message.id,
                     message="",
                     skill_calls=skill_calls,
                     attachments=cached_attachments,
@@ -632,9 +638,6 @@ async def stream_agent(message: ChatMessageCreate):
                     time_cost=this_time - last,
                 )
                 last = this_time
-                if cold_start_cost > 0:
-                    skill_message_create.cold_start_cost = cold_start_cost
-                    cold_start_cost = 0
                 # save message and credit in one transaction
                 async with get_session() as session:
                     if payment_enabled:
@@ -648,7 +651,7 @@ async def stream_agent(message: ChatMessageCreate):
                                 session,
                                 payer,
                                 skill_message_create.id,
-                                input.id,
+                                user_message.id,
                                 message_amount,
                                 agent,
                             )
@@ -666,7 +669,7 @@ async def stream_agent(message: ChatMessageCreate):
                                 session,
                                 payer,
                                 skill_message_create.id,
-                                input.id,
+                                user_message.id,
                                 skill_call["id"],
                                 skill_call["name"],
                                 agent,
@@ -674,7 +677,7 @@ async def stream_agent(message: ChatMessageCreate):
                             skill_call["credit_event_id"] = payment_event.id
                             skill_call["credit_cost"] = payment_event.total_amount
                             logger.info(
-                                f"[{input.agent_id}] skill payment: {skill_call}"
+                                f"[{user_message.agent_id}] skill payment: {skill_call}"
                             )
                     skill_message_create.skill_calls = skill_calls
                     skill_message = await skill_message_create.save_in_session(session)
@@ -700,36 +703,31 @@ async def stream_agent(message: ChatMessageCreate):
                                 content = msg.content[0]
                             post_model_message_create = ChatMessageCreate(
                                 id=str(XID()),
-                                agent_id=input.agent_id,
-                                chat_id=input.chat_id,
-                                user_id=input.user_id,
-                                author_id=input.agent_id,
+                                agent_id=user_message.agent_id,
+                                chat_id=user_message.chat_id,
+                                user_id=user_message.user_id,
+                                author_id=user_message.agent_id,
                                 author_type=AuthorType.AGENT,
                                 model=agent.model,
-                                thread_type=input.author_type,
-                                reply_to=input.id,
+                                thread_type=user_message.author_type,
+                                reply_to=user_message.id,
                                 message=content,
                                 input_tokens=0,
                                 output_tokens=0,
                                 time_cost=this_time - last,
                             )
                             last = this_time
-                            if cold_start_cost > 0:
-                                post_model_message_create.cold_start_cost = (
-                                    cold_start_cost
-                                )
-                                cold_start_cost = 0
                             post_model_message = await post_model_message_create.save()
                             yield post_model_message
                         error_message_create = (
                             await ChatMessageCreate.from_system_message(
                                 SystemMessageType.INSUFFICIENT_BALANCE,
-                                agent_id=input.agent_id,
-                                chat_id=input.chat_id,
-                                user_id=input.user_id,
-                                author_id=input.agent_id,
-                                thread_type=input.author_type,
-                                reply_to=input.id,
+                                agent_id=user_message.agent_id,
+                                chat_id=user_message.chat_id,
+                                user_id=user_message.user_id,
+                                author_id=user_message.agent_id,
+                                thread_type=user_message.author_type,
+                                reply_to=user_message.id,
                                 time_cost=0,
                             )
                         )
@@ -749,12 +747,12 @@ async def stream_agent(message: ChatMessageCreate):
         )
         error_message_create = await ChatMessageCreate.from_system_message(
             SystemMessageType.AGENT_INTERNAL_ERROR,
-            agent_id=input.agent_id,
-            chat_id=input.chat_id,
-            user_id=input.user_id,
-            author_id=input.agent_id,
-            thread_type=input.author_type,
-            reply_to=input.id,
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -764,16 +762,16 @@ async def stream_agent(message: ChatMessageCreate):
         error_traceback = traceback.format_exc()
         logger.error(
             f"reached recursion limit: {str(e)}\n{error_traceback}",
-            extra={"thread_id": thread_id, "agent_id": input.agent_id},
+            extra={"thread_id": thread_id, "agent_id": user_message.agent_id},
         )
         error_message_create = await ChatMessageCreate.from_system_message(
             SystemMessageType.STEP_LIMIT_EXCEEDED,
-            agent_id=input.agent_id,
-            chat_id=input.chat_id,
-            user_id=input.user_id,
-            author_id=input.agent_id,
-            thread_type=input.author_type,
-            reply_to=input.id,
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -783,21 +781,21 @@ async def stream_agent(message: ChatMessageCreate):
         error_traceback = traceback.format_exc()
         logger.error(
             f"failed to execute agent: {str(e)}\n{error_traceback}",
-            extra={"thread_id": thread_id, "agent_id": input.agent_id},
+            extra={"thread_id": thread_id, "agent_id": user_message.agent_id},
         )
         error_message_create = await ChatMessageCreate.from_system_message(
             SystemMessageType.AGENT_INTERNAL_ERROR,
-            agent_id=input.agent_id,
-            chat_id=input.chat_id,
-            user_id=input.user_id,
-            author_id=input.agent_id,
-            thread_type=input.author_type,
-            reply_to=input.id,
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
         yield error_message
-        await clear_thread_memory(input.agent_id, input.chat_id)
+        await clear_thread_memory(user_message.agent_id, user_message.chat_id)
         return
 
 

intentkit/core/node.py

@@ -81,10 +81,10 @@ class PreModelNode(RunnableCallable):
         self.func_accepts_config = True
 
     def _parse_input(
-        self, input: AgentState
+        self, state: AgentState
     ) -> tuple[list[AnyMessage], dict[str, Any]]:
-        messages = input.get("messages")
-        context = input.get("context", {})
+        messages = state.get("messages")
+        context = state.get("context", {})
         if messages is None or not isinstance(messages, list) or len(messages) == 0:
             raise ValueError("Missing required field `messages` in the input.")
         return messages, context
@@ -107,13 +107,13 @@ class PreModelNode(RunnableCallable):
     def _func(self, AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(self, input: AgentState) -> dict[str, Any]:
-        messages, context = self._parse_input(input)
+    async def _afunc(self, state: AgentState) -> dict[str, Any]:
+        messages, context = self._parse_input(state)
         try:
             _validate_chat_history(messages)
         except ValueError as e:
             logger.error(f"Invalid chat history: {e}")
-            logger.info(input)
+            logger.info(state)
             # delete all messages
             return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
         if self.short_term_memory_strategy == "trim":
@@ -162,7 +162,7 @@ class PreModelNode(RunnableCallable):
                 return self._prepare_state_update(context, summarization_result)
             except ValueError as e:
                 logger.error(f"Invalid chat history: {e}")
-                logger.info(input)
+                logger.info(state)
                 # delete all messages
                 return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
         raise ValueError(
@@ -175,15 +175,15 @@ class PostModelNode(RunnableCallable):
         super().__init__(self._func, self._afunc, name="post_model_node", trace=False)
         self.func_accepts_config = True
 
-    def _func(self, input: AgentState) -> dict[str, Any]:
+    def _func(self, state: AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(self, input: AgentState) -> dict[str, Any]:
+    async def _afunc(self, state: AgentState) -> dict[str, Any]:
         runtime = get_runtime(AgentContext)
         context = runtime.context
-        logger.debug(f"Running PostModelNode, input: {input}, context: {context}")
+        logger.debug(f"Running PostModelNode, input: {state}, context: {context}")
         state_update = {}
-        messages = input.get("messages")
+        messages = state.get("messages")
         if messages is None or not isinstance(messages, list) or len(messages) == 0:
             raise ValueError("Missing required field `messages` in the input.")
         payer = context.payer

intentkit/skills/venice_audio/input.py

@@ -12,7 +12,7 @@ class VeniceAudioInput(BaseModel):
     Defines parameters controllable by the user when invoking the tool.
     """
 
-    input: str = Field(
+    voice_input: str = Field(
         ...,  # Ellipsis (...) indicates this field is required
         description="The text to generate audio for. Maximum length is 4096 characters.",
         min_length=1,  # As per API docs: Required string length: 1

intentkit/skills/venice_audio/venice_audio.py

@@ -40,7 +40,7 @@ class VeniceAudioTool(VeniceAudioBaseTool):
 
     async def _arun(
         self,
-        input: str,
+        voice_input: str,
         voice_model: str,
         speed: Optional[float] = 1.0,
         response_format: Optional[AllowedAudioFormat] = "mp3",
@@ -98,7 +98,7 @@ class VeniceAudioTool(VeniceAudioBaseTool):
             # --- Prepare API Call ---
             payload: Dict[str, Any] = {
                 "model": tts_model_id,
-                "input": input,
+                "input": voice_input,
                 "voice": voice_model,
                 "response_format": final_response_format,
                 "speed": speed if speed is not None else 1.0,
@@ -208,7 +208,7 @@ class VeniceAudioTool(VeniceAudioBaseTool):
                         "tts_engine": tts_model_id,
                         "speed": speed if speed is not None else 1.0,
                         "response_format": final_response_format,
-                        "input_text_length": len(input),
+                        "input_text_length": len(voice_input),
                         "error": False,
                         "status_code": response.status_code,
                     }

{intentkit-0.7.5.dev18.dist-info → intentkit-0.7.5.dev19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.7.5.dev18
+Version: 0.7.5.dev19
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit

{intentkit-0.7.5.dev18.dist-info → intentkit-0.7.5.dev19.dist-info}/RECORD

@@ -1,9 +1,9 @@
-intentkit/__init__.py,sha256=-mscj0_i9qDAR-j1pgBVo_G85FZS3SZEf7ncYlpJjsI,384
+intentkit/__init__.py,sha256=vC3AH1dexdHSEV7Bq6Rn5KTbRiLuFt0PZkhsTwoz-Qk,384
 intentkit/abstracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 intentkit/abstracts/agent.py,sha256=108gb5W8Q1Sy4G55F2_ZFv2-_CnY76qrBtpIr0Oxxqk,1489
 intentkit/abstracts/api.py,sha256=ZUc24vaQvQVbbjznx7bV0lbbQxdQPfEV8ZxM2R6wZWo,166
 intentkit/abstracts/engine.py,sha256=C5C9d8vVMePhkKWURKIAbZSDZnmjxj5epL_04E6RpxQ,1449
-intentkit/abstracts/graph.py,sha256=sX5hVemXsODvwIYLHufaf-zSXmW97bXRoZuyxYqaEV4,1128
+intentkit/abstracts/graph.py,sha256=j43cNpWouXLmWl80gLDs8gCLcHkiaWAJNbT2vQuXcpg,1137
 intentkit/abstracts/skill.py,sha256=cIJ6BkASD31U1IEkE8rdAawq99w_xsg0lt3oalqa1ZA,5071
 intentkit/abstracts/twitter.py,sha256=cEtP7ygR_b-pHdc9i8kBuyooz1cPoGUGwsBHDpowJyY,1262
 intentkit/clients/__init__.py,sha256=pT_4I7drnuiNWPvYAU_CUAv50PjyaqEAsm_kp-vMPW4,372
@@ -18,8 +18,8 @@ intentkit/core/api.py,sha256=WfoaHNquujYJIpNPuTR1dSaaxog0S3X2W4lG9Ehmkm4,3284
 intentkit/core/chat.py,sha256=YN20CnDazWLjiOZFOHgV6uHmA2DKkvPCsD5Q5sfNcZg,1685
 intentkit/core/client.py,sha256=J5K7f08-ucszBKAbn9K3QNOFKIC__7amTbKYii1jFkI,3056
 intentkit/core/credit.py,sha256=b4f4T6G6eeBTMe0L_r8awWtXgUnqiog4IUaymDPYym0,75587
-intentkit/core/engine.py,sha256=r5d_DmekzuGzpwbh-zkSQCa8-zO4WlnoIvukxxmDmJ8,36963
-intentkit/core/node.py,sha256=7h9zgDSd928bzUi3m3EZnKkhbwqlbRAQUr_uz7gKB5Y,8880
+intentkit/core/engine.py,sha256=SnYBwcZli2Sn0yRaoQ-Okc3zJt86hxhaXqjwIgTKKiw,37226
+intentkit/core/node.py,sha256=P0LiBrjFtNBVC0JpQntTgDVfaLJM8aqhJZCJfPx6MJ0,8880
 intentkit/core/prompt.py,sha256=idNx1ono4Maz2i6IBKfaKOBBbEQiWbaSxr2Eb1vZTI4,15482
 intentkit/models/agent.py,sha256=yXulE5vlOOku6DSiid_Jp6OCfqy3-XN47rmKax5xX1w,67582
 intentkit/models/agent_data.py,sha256=5zq3EPKnygT2P1OHc2IfEmL8hXkjeBND6sJ0JJsvQJg,28370
@@ -379,9 +379,9 @@ intentkit/skills/unrealspeech/text_to_speech.py,sha256=QsCeOdPtlObQKCVNm6A9jKK55
 intentkit/skills/unrealspeech/unrealspeech.jpg,sha256=t-6RkYflJrL3Pvf5aA_VPAR_QlGyKUImXZBJLiyR3xY,8201
 intentkit/skills/venice_audio/__init__.py,sha256=E39CeSUHRoGV9IxNUtwo-nCp0Yfq5rvcrq1N61ygwGc,3309
 intentkit/skills/venice_audio/base.py,sha256=1oxHrmDXpBZbA7q2BqatlpuY-X3uwhK22T8QZjKmkqw,4845
-intentkit/skills/venice_audio/input.py,sha256=nWsbW40Bd-Q331PpBZ-NBcsgw3pqEWsWIvY0lsbNR4A,1887
+intentkit/skills/venice_audio/input.py,sha256=3pXfgkXuS4ezAVPJMY-XQwgd2Mas58BQnJph1Af8QkA,1893
 intentkit/skills/venice_audio/schema.json,sha256=g3cb9zJvinnRrilvNIAdG8qivgGyB7sHCEC8392MXhY,5268
-intentkit/skills/venice_audio/venice_audio.py,sha256=3xIUbNZ_ZZ5J2FYJzGaJ0ZCwX_IpAouVuoTyl0JI72Q,11305
+intentkit/skills/venice_audio/venice_audio.py,sha256=h03Lf3t58CRDq2U6Lb1Y_Hp8oZ-FBlp0fxUF-hpxPbE,11323
 intentkit/skills/venice_audio/venice_logo.jpg,sha256=XDnVdh3V8UuJjAeSmp4rbqhTKn0yjRI6M_6z1DSs8cA,13342
 intentkit/skills/venice_image/README.md,sha256=79NWUOaYWeFLOhR7m424pLIZ7VT0fhkxSBcohoy8Oh0,5017
 intentkit/skills/venice_image/__init__.py,sha256=fPq9OS8er67cn3zyo9H_7iEj5cSUu7nOmqhhjwG9xNs,5841
@@ -450,7 +450,7 @@ intentkit/utils/random.py,sha256=DymMxu9g0kuQLgJUqalvgksnIeLdS-v0aRk5nQU0mLI,452
 intentkit/utils/s3.py,sha256=A8Nsx5QJyLsxhj9g7oHNy2-m24tjQUhC9URm8Qb1jFw,10057
 intentkit/utils/slack_alert.py,sha256=s7UpRgyzLW7Pbmt8cKzTJgMA9bm4EP-1rQ5KXayHu6E,2264
 intentkit/utils/tx.py,sha256=2yLLGuhvfBEY5n_GJ8wmIWLCzn0FsYKv5kRNzw_sLUI,1454
-intentkit-0.7.5.dev18.dist-info/METADATA,sha256=PVVfMq5it9ZfQ2dcbtvqX9Zem0OGfa1vInUjVgl0Lg0,6360
-intentkit-0.7.5.dev18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-intentkit-0.7.5.dev18.dist-info/licenses/LICENSE,sha256=Bln6DhK-LtcO4aXy-PBcdZv2f24MlJFm_qn222biJtE,1071
-intentkit-0.7.5.dev18.dist-info/RECORD,,
+intentkit-0.7.5.dev19.dist-info/METADATA,sha256=mKeFmE8ZlUdWm6hR1TGH2h2omjKJg6mOcT8DjpjkCiw,6360
+intentkit-0.7.5.dev19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+intentkit-0.7.5.dev19.dist-info/licenses/LICENSE,sha256=Bln6DhK-LtcO4aXy-PBcdZv2f24MlJFm_qn222biJtE,1071
+intentkit-0.7.5.dev19.dist-info/RECORD,,