intentkit 0.7.5.dev17__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-dev17"
+__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/config/config.py

@@ -1,5 +1,3 @@
-# app/config.py
-import asyncio
 import json
 import logging
 import os
@@ -11,9 +9,6 @@ from intentkit.utils.logging import setup_logging
 from intentkit.utils.s3 import init_s3
 from intentkit.utils.slack_alert import init_slack
 
-# hack for cdp bug
-asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
-
 # Load environment variables from .env file
 load_dotenv()
 

intentkit/core/engine.py

@@ -21,6 +21,7 @@ from typing import Optional, Tuple
 
 import sqlalchemy
 from epyxid import XID
+from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     BaseMessage,
     HumanMessage,
@@ -29,6 +30,7 @@ from langchain_core.tools import BaseTool
 from langgraph.errors import GraphRecursionError
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.prebuilt import create_react_agent
+from langgraph.runtime import Runtime
 from sqlalchemy import func, update
 from sqlalchemy.exc import SQLAlchemyError
 
@@ -63,15 +65,13 @@ 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 create_agent(agent: Agent, is_private: bool = False) -> CompiledStateGraph:
-    """Create an AI agent with specified configuration and tools.
+async def build_agent(agent: Agent, agent_data: AgentData) -> CompiledStateGraph:
+    """Build an AI agent with specified configuration and tools.
 
     This function:
     1. Initializes LLM with specified model
@@ -81,13 +81,12 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     Args:
         agent (Agent): Agent configuration object
+        agent_data (AgentData): Agent data object
         is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
-        has_search (bool, optional): Flag indicating whether to include search tools. Defaults to False.
 
     Returns:
         CompiledStateGraph: Initialized LangChain agent
     """
-    agent_data = await AgentData.get(agent.id)
 
     # Create the LLM model instance
     llm_model = await create_llm_model(
@@ -108,6 +107,7 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     # ==== Load skills
     tools: list[BaseTool | dict] = []
+    private_tools: list[BaseTool | dict] = []
 
     if agent.skills:
         for k, v in agent.skills.items():
@@ -116,11 +116,18 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
             try:
                 skill_module = importlib.import_module(f"intentkit.skills.{k}")
                 if hasattr(skill_module, "get_skills"):
+                    # all
                     skill_tools = await skill_module.get_skills(
-                        v, is_private, agent_store, agent_id=agent.id
+                        v, False, agent_store, agent_id=agent.id
                     )
                     if skill_tools and len(skill_tools) > 0:
                         tools.extend(skill_tools)
+                    # private
+                    skill_private_tools = await skill_module.get_skills(
+                        v, True, agent_store, agent_id=agent.id
+                    )
+                    if skill_private_tools and len(skill_private_tools) > 0:
+                        private_tools.extend(skill_private_tools)
                 else:
                     logger.error(f"Skill {k} does not have get_skills function")
             except ImportError as e:
@@ -128,23 +135,33 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     # filter the duplicate tools
     tools = list({tool.name: tool for tool in tools}.values())
+    private_tools = list({tool.name: tool for tool in private_tools}.values())
 
     # Add search tools if requested
     if (
-        llm_model.info.provider == LLMProvider.OPENAI
-        and llm_model.info.supports_search
-        and not agent.model.startswith(
-            "gpt-5"
-        )  # tmp disable gpt-5 search since package bugs
+        llm_model.info.provider == LLMProvider.OPENAI and llm_model.info.supports_search
+        # and not agent.model.startswith(
+        #     "gpt-5"
+        # )  # tmp disable gpt-5 search since package bugs
     ):
         tools.append({"type": "web_search_preview"})
+        private_tools.append({"type": "web_search_preview"})
 
     # Create the formatted_prompt function using the refactored prompt module
     formatted_prompt = create_formatted_prompt_function(agent, agent_data)
 
+    # bind tools to llm
+    def select_model(
+        state: AgentState, runtime: Runtime[AgentContext]
+    ) -> BaseChatModel:
+        context = runtime.context
+        if context.is_private:
+            return llm.bind_tools(private_tools)
+        return llm.bind_tools(tools)
+
     for tool in tools:
         logger.info(
-            f"[{agent.id}{'-private' if is_private else ''}] loaded tool: {tool.name if isinstance(tool, BaseTool) else tool}"
+            f"[{agent.id}] loaded tool: {tool.name if isinstance(tool, BaseTool) else tool}"
         )
 
     # Pre model hook
@@ -157,7 +174,7 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
 
     # Create ReAct Agent using the LLM and CDP Agentkit tools.
     executor = create_react_agent(
-        model=llm,
+        model=select_model,
         tools=tools,
         prompt=formatted_prompt,
         pre_model_hook=pre_model_hook,
@@ -172,7 +189,23 @@ async def create_agent(agent: Agent, is_private: bool = False) -> CompiledStateG
     return executor
 
 
-async def initialize_agent(aid, is_private=False):
+async def create_agent(agent: Agent) -> CompiledStateGraph:
+    """Create an AI agent with specified configuration and tools.
+
+    This function maintains backward compatibility by calling build_agent internally.
+
+    Args:
+        agent (Agent): Agent configuration object
+        is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
+
+    Returns:
+        CompiledStateGraph: Initialized LangChain agent
+    """
+    agent_data = await AgentData.get(agent.id)
+    return await build_agent(agent, agent_data)
+
+
+async def initialize_agent(aid):
     """Initialize an AI agent with specified configuration and tools.
 
     This function:
@@ -198,47 +231,34 @@ async def initialize_agent(aid, is_private=False):
         )
 
     # Create the agent using the new create_agent function
-    executor = await create_agent(agent, is_private)
+    executor = await create_agent(agent)
 
     # Cache the agent executor
-    if is_private:
-        _private_agents[aid] = executor
-        _private_agents_updated[aid] = agent.updated_at
-    else:
-        _agents[aid] = executor
-        _agents_updated[aid] = agent.updated_at
+    _agents[aid] = executor
+    _agents_updated[aid] = agent.deployed_at if agent.deployed_at else agent.updated_at
 
 
-async def agent_executor(
-    agent_id: str, is_private: bool
-) -> Tuple[CompiledStateGraph, float]:
+async def agent_executor(agent_id: str) -> Tuple[CompiledStateGraph, float]:
     start = time.perf_counter()
     agent = await Agent.get(agent_id)
     if not agent:
         raise IntentKitAPIError(
             status_code=404, key="AgentNotFound", message="Agent not found"
         )
-    agents = _private_agents if is_private else _agents
-    agents_updated = _private_agents_updated if is_private else _agents_updated
-
+    updated_at = agent.deployed_at if agent.deployed_at else agent.updated_at
     # Check if agent needs reinitialization due to updates
     needs_reinit = False
-    if agent_id in agents:
-        if (
-            agent_id not in agents_updated
-            or agent.updated_at != agents_updated[agent_id]
-        ):
+    if agent_id in _agents:
+        if agent_id not in _agents_updated or updated_at != _agents_updated[agent_id]:
             needs_reinit = True
-            logger.info(
-                f"Reinitializing agent {agent_id} due to updates, private mode: {is_private}"
-            )
+            logger.info(f"Reinitializing agent {agent_id} due to updates")
 
     # cold start or needs reinitialization
     cold_start_cost = 0.0
-    if (agent_id not in agents) or needs_reinit:
-        await initialize_agent(agent_id, is_private)
+    if (agent_id not in _agents) or needs_reinit:
+        await initialize_agent(agent_id)
         cold_start_cost = time.perf_counter() - start
-    return agents[agent_id], cold_start_cost
+    return _agents[agent_id], cold_start_cost
 
 
 async def stream_agent(message: ChatMessageCreate):
@@ -257,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()
-
-    # agent
-    agent = await Agent.get(input.agent_id)
+    user_message = await message.save()
 
-    # 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",
@@ -285,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,
@@ -321,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()
@@ -339,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()
@@ -352,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, is_private)
-    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
@@ -424,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,
@@ -432,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,
     )
@@ -474,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)
@@ -496,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
@@ -519,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
@@ -527,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(
@@ -582,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,
@@ -610,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:
@@ -626,7 +651,7 @@ async def stream_agent(message: ChatMessageCreate):
                                 session,
                                 payer,
                                 skill_message_create.id,
-                                input.id,
+                                user_message.id,
                                 message_amount,
                                 agent,
                             )
@@ -644,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,
@@ -652,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)
@@ -678,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,
                             )
                         )
@@ -727,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()
@@ -742,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()
@@ -761,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
 
 
@@ -889,10 +909,7 @@ async def clean_agent_memory(
 async def thread_stats(agent_id: str, chat_id: str) -> list[BaseMessage]:
     thread_id = f"{agent_id}-{chat_id}"
     stream_config = {"configurable": {"thread_id": thread_id}}
-    is_private = False
-    if chat_id.startswith("owner") or chat_id.startswith("autonomous"):
-        is_private = True
-    executor, _ = await agent_executor(agent_id, is_private)
+    executor, _ = await agent_executor(agent_id)
     snap = await executor.aget_state(stream_config)
     if snap.values and "messages" in snap.values:
         return snap.values["messages"]