intentkit 0.7.5.dev18__tar.gz → 0.7.5.dev20__tar.gz

{intentkit-0.7.5.dev18 → intentkit-0.7.5.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.7.5.dev18
+Version: 0.7.5.dev20
 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 → intentkit-0.7.5.dev20}/__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-dev20"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.7.5.dev18 → intentkit-0.7.5.dev20}/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-0.7.5.dev18 → intentkit-0.7.5.dev20}/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:
@@ -146,8 +144,8 @@ async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph
         #     "gpt-5"
         # )  # tmp disable gpt-5 search since package bugs
     ):
-        tools.append({"type": "web_search_preview"})
-        private_tools.append({"type": "web_search_preview"})
+        tools.append({"type": "web_search"})
+        private_tools.append({"type": "web_search"})
 
     # Create the formatted_prompt function using the refactored prompt module
     formatted_prompt = create_formatted_prompt_function(agent, agent_data)
@@ -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-0.7.5.dev18 → intentkit-0.7.5.dev20}/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-0.7.5.dev18 → intentkit-0.7.5.dev20}/models/agent.py

@@ -1159,23 +1159,29 @@ class Agent(AgentCreate, AgentPublicInfo):
     statistics: Annotated[
         Optional[Dict[str, Any]],
         PydanticField(
-            description="Statistics of the agent, update every 1 hour for query"
+            default=None,
+            description="Statistics of the agent, update every 1 hour for query",
         ),
     ]
     assets: Annotated[
         Optional[Dict[str, Any]],
-        PydanticField(description="Assets of the agent, update every 1 hour for query"),
+        PydanticField(
+            default=None,
+            description="Assets of the agent, update every 1 hour for query",
+        ),
     ]
     account_snapshot: Annotated[
         Optional[CreditAccount],
         PydanticField(
-            description="Account snapshot of the agent, update every 1 hour for query"
+            default=None,
+            description="Account snapshot of the agent, update every 1 hour for query",
         ),
     ]
     extra: Annotated[
         Optional[Dict[str, Any]],
         PydanticField(
-            description="Other helper data fields for query, come from agent and agent data"
+            default=None,
+            description="Other helper data fields for query, come from agent and agent data",
         ),
     ]
     deployed_at: Annotated[

{intentkit-0.7.5.dev18 → intentkit-0.7.5.dev20}/models/llm.csv

@@ -5,7 +5,7 @@ gpt-4.1-nano,GPT-4.1 Nano,openai,TRUE,0.1,0.4,1,128000,4096,3,5,FALSE,TRUE,TRUE,
 gpt-4.1-mini,GPT-4.1 Mini,openai,TRUE,0.4,1.6,2,128000,4096,4,4,FALSE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,FALSE,,180
 gpt-4.1,GPT-4.1,openai,TRUE,2,8,4,128000,4096,5,3,TRUE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,FALSE,,180
 gpt-5-nano,GPT-5 Nano,openai,TRUE,0.05,0.4,1,400000,128000,3,5,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,,180
-gpt-5-mini,GPT-5 Mini,openai,TRUE,0.25,2,2,400000,128000,4,4,TRUE,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,,180
+gpt-5-mini,GPT-5 Mini,openai,TRUE,0.25,2,2,400000,128000,4,4,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,,180
 gpt-5,GPT-5,openai,TRUE,1.25,10,4,400000,128000,5,3,TRUE,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,,180
 o3,OpenAI o3,openai,TRUE,2,8,4,200000,100000,5,1,TRUE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,,180
 o4-mini,OpenAI o4-mini,openai,TRUE,1.1,4.4,3,128000,4096,4,3,FALSE,TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,,180

{intentkit-0.7.5.dev18 → intentkit-0.7.5.dev20}/models/llm.py

@@ -387,8 +387,10 @@ class OpenAILLM(LLMModel):
         if info.api_base:
             kwargs["openai_api_base"] = info.api_base
 
-        if self.model_name.startswith("gpt-5"):
+        if self.model_name.startswith("gpt-5-"):
             kwargs["reasoning_effort"] = "minimal"
+        elif self.model_name == "gpt-5":
+            kwargs["reasoning_effort"] = "low"
 
         logger.debug(f"Creating ChatOpenAI instance with kwargs: {kwargs}")
 

{intentkit-0.7.5.dev18 → intentkit-0.7.5.dev20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.7.5-dev18"
+version = "0.7.5-dev20"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.7.5.dev18 → intentkit-0.7.5.dev20}/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-0.7.5.dev18 → intentkit-0.7.5.dev20}/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,
                     }