intentkit 0.6.12__tar.gz → 0.6.13__tar.gz

{intentkit-0.6.12 → intentkit-0.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.12
+Version: 0.6.13
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

{intentkit-0.6.12 → intentkit-0.6.13}/__init__.py

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

{intentkit-0.6.12 → intentkit-0.6.13}/abstracts/graph.py

@@ -1,11 +1,12 @@
 import asyncio
 from enum import Enum
-from typing import Any, Dict, Literal, NotRequired, Optional
+from typing import Any, Dict, NotRequired, Optional
 
 from langgraph.prebuilt.chat_agent_executor import AgentState as BaseAgentState
 from pydantic import BaseModel
 
 from intentkit.models.agent import Agent
+from intentkit.models.chat import AuthorType
 
 
 class AgentError(str, Enum):
@@ -31,7 +32,7 @@ class AgentContext(BaseModel):
     chat_id: str
     user_id: Optional[str] = None
     app_id: Optional[str] = None
-    entrypoint: Literal["web", "twitter", "telegram", "trigger", "api"]
+    entrypoint: AuthorType
     is_private: bool
     payer: Optional[str] = None
 

{intentkit-0.6.12 → intentkit-0.6.13}/config/config.py

@@ -96,9 +96,16 @@ class Config:
         self.eternal_api_key = self.load("ETERNAL_API_KEY")
         self.reigent_api_key = self.load("REIGENT_API_KEY")
         self.venice_api_key = self.load("VENICE_API_KEY")
+        # LLM Config
         self.system_prompt = self.load("SYSTEM_PROMPT")
         self.input_token_limit = self.load_int("INPUT_TOKEN_LIMIT", 60000)
+        # XMTP
+        self.xmtp_system_prompt = self.load(
+            "XMTP_SYSTEM_PROMPT",
+            "You are assisting a user who uses an XMTP client that only displays plain-text messages, so do not use Markdown formatting.",
+        )
         # Telegram server settings
+        self.tg_system_prompt = self.load("TG_SYSTEM_PROMPT")
         self.tg_base_url = self.load("TG_BASE_URL")
         self.tg_server_host = self.load("TG_SERVER_HOST", "127.0.0.1")
         self.tg_server_port = self.load("TG_SERVER_PORT", "8081")

intentkit-0.6.13/core/api.py

@@ -0,0 +1,100 @@
+"""Core API Router.
+
+This module provides the core API endpoints for agent execution and management.
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Body
+from fastapi.responses import StreamingResponse
+from pydantic import AfterValidator
+
+from intentkit.core.engine import execute_agent, stream_agent
+from intentkit.models.chat import ChatMessage, ChatMessageCreate
+
+core_router = APIRouter(prefix="/core", tags=["Core"])
+
+
+@core_router.post("/execute", response_model=list[ChatMessage])
+async def execute(
+    message: Annotated[
+        ChatMessageCreate, AfterValidator(ChatMessageCreate.model_validate)
+    ] = Body(
+        ChatMessageCreate,
+        description="The chat message containing agent_id, chat_id and message content",
+    ),
+) -> list[ChatMessage]:
+    """Execute an agent with the provided message and return all results.
+
+    This endpoint executes an agent with the provided message and returns all
+    generated messages as a complete list after execution finishes.
+
+    **Request Body:**
+    * `message` - The chat message containing agent_id, chat_id and message content
+
+    **Response:**
+    Returns a list of ChatMessage objects containing:
+    * Skill call results (including tool executions)
+    * Agent reasoning and responses
+    * System messages or error notifications
+
+    **Returns:**
+    * `list[ChatMessage]` - Complete list of response messages
+
+    **Raises:**
+    * `HTTPException`:
+        - 400: If input parameters are invalid
+        - 404: If agent not found
+        - 500: For other server-side errors
+    """
+    return await execute_agent(message)
+
+
+@core_router.post("/stream")
+async def stream(
+    message: Annotated[
+        ChatMessageCreate, AfterValidator(ChatMessageCreate.model_validate)
+    ] = Body(
+        ChatMessageCreate,
+        description="The chat message containing agent_id, chat_id and message content",
+    ),
+) -> StreamingResponse:
+    """Stream agent execution results in real-time using Server-Sent Events.
+
+    This endpoint executes an agent with the provided message and streams the results
+    in real-time using the SSE (Server-Sent Events) standard format.
+
+    **Request Body:**
+    * `message` - The chat message containing agent_id, chat_id and message content
+
+    **Stream Format:**
+    The response uses Server-Sent Events with the following format:
+    * Event type: `message`
+    * Data: ChatMessage object as JSON
+    * Format: `event: message\\ndata: {ChatMessage JSON}\\n\\n`
+
+    **Response Content:**
+    Each streamed message can be:
+    * Skill call results (including tool executions)
+    * Agent reasoning and responses
+    * System messages or error notifications
+
+    **Returns:**
+    * `StreamingResponse` - SSE stream with real-time ChatMessage objects
+
+    **Raises:**
+    * `HTTPException`:
+        - 400: If input parameters are invalid
+        - 404: If agent not found
+        - 500: For other server-side errors
+    """
+
+    async def generate():
+        async for chat_message in stream_agent(message):
+            yield f"event: message\ndata: {chat_message.model_dump_json()}\n\n"
+
+    return StreamingResponse(
+        generate(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )

intentkit-0.6.13/core/client.py

@@ -0,0 +1,85 @@
+"""Core Client Module.
+
+This module provides client functions for core API endpoints with environment-aware routing.
+"""
+
+from typing import AsyncIterator
+
+import httpx
+
+from intentkit.config.config import config
+from intentkit.core.engine import execute_agent as local_execute_agent
+from intentkit.core.engine import stream_agent as local_stream_agent
+from intentkit.models.chat import ChatMessage, ChatMessageCreate
+
+
+async def execute_agent(message: ChatMessageCreate) -> list[ChatMessage]:
+    """Execute an agent with environment-aware routing.
+
+    In local environment, directly calls the local execute_agent function.
+    In other environments, makes HTTP request to the core API endpoint.
+
+    Args:
+        message (ChatMessage): The chat message containing agent_id, chat_id and message content
+        debug (bool): Enable debug mode
+
+    Returns:
+        list[ChatMessage]: Formatted response lines from agent execution
+
+    Raises:
+        HTTPException: For API errors (in non-local environment)
+        Exception: For other execution errors
+    """
+    if config.env == "local":
+        return await local_execute_agent(message)
+
+    # Make HTTP request in non-local environment
+    url = f"{config.internal_base_url}/core/execute"
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            url,
+            json=message.model_dump(mode="json"),
+            timeout=300,
+        )
+    response.raise_for_status()
+    json_data = response.json()
+    return [ChatMessage.model_validate(msg) for msg in json_data]
+
+
+async def stream_agent(message: ChatMessageCreate) -> AsyncIterator[ChatMessage]:
+    """Stream agent execution with environment-aware routing using Server-Sent Events.
+
+    In local environment, directly calls the local stream_agent function.
+    In other environments, makes HTTP request to the core stream API endpoint and parses SSE format.
+
+    Args:
+        message (ChatMessageCreate): The chat message containing agent_id, chat_id and message content
+        debug (bool): Enable debug mode
+
+    Yields:
+        ChatMessage: Individual response messages from agent execution
+
+    Raises:
+        HTTPException: For API errors (in non-local environment)
+        Exception: For other execution errors
+    """
+    if config.env == "local":
+        async for chat_message in local_stream_agent(message):
+            yield chat_message
+        return
+
+    # Make HTTP request in non-local environment
+    url = f"{config.internal_base_url}/core/stream"
+    async with httpx.AsyncClient() as client:
+        async with client.stream(
+            "POST",
+            url,
+            json=message.model_dump(mode="json"),
+            timeout=300,
+        ) as response:
+            response.raise_for_status()
+            async for line in response.aiter_lines():
+                if line.startswith("data: "):
+                    json_str = line[6:]  # Remove "data: " prefix
+                    if json_str.strip():
+                        yield ChatMessage.model_validate_json(json_str)

{intentkit-0.6.12 → intentkit-0.6.13}/core/engine.py

@@ -758,7 +758,7 @@ async def stream_agent(message: ChatMessageCreate):
             author_type=AuthorType.SYSTEM,
             thread_type=input.author_type,
             reply_to=input.id,
-            message="IntentKit Internal Error",
+            message="Agent Internal Error",
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -800,7 +800,7 @@ async def stream_agent(message: ChatMessageCreate):
             author_type=AuthorType.SYSTEM,
             thread_type=input.author_type,
             reply_to=input.id,
-            message="Internal Agent Error",
+            message="Agent Internal Error",
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()

{intentkit-0.6.12 → intentkit-0.6.13}/core/prompt.py

@@ -252,23 +252,6 @@ def escape_prompt(prompt: str) -> str:
 # ============================================================================
 
 
-def _build_social_entrypoint_prompt(agent: Agent, entrypoint: str) -> Optional[str]:
-    """Build prompt for social media entrypoints (Twitter, Telegram)."""
-    if (
-        agent.twitter_entrypoint_enabled
-        and agent.twitter_entrypoint_prompt
-        and entrypoint == AuthorType.TWITTER.value
-    ):
-        return agent.twitter_entrypoint_prompt
-    elif (
-        agent.telegram_entrypoint_enabled
-        and agent.telegram_entrypoint_prompt
-        and entrypoint == AuthorType.TELEGRAM.value
-    ):
-        return agent.telegram_entrypoint_prompt
-    return None
-
-
 def _build_autonomous_task_prompt(agent: Agent, context: AgentContext) -> str:
     """Build prompt for autonomous task entrypoint."""
     task_id = context.chat_id.removeprefix("autonomous-")
@@ -327,11 +310,18 @@ async def build_entrypoint_prompt(agent: Agent, context: AgentContext) -> Option
     entrypoint_prompt = None
 
     # Handle social media entrypoints
-    entrypoint_prompt = _build_social_entrypoint_prompt(agent, entrypoint)
-
-    # Handle autonomous task entrypoint
-    if not entrypoint_prompt and entrypoint == AuthorType.TRIGGER.value:
-        entrypoint_prompt = _build_autonomous_task_prompt(agent, context)
+    if entrypoint == AuthorType.TELEGRAM.value:
+        if config.tg_system_prompt:
+            entrypoint_prompt = "\n\n" + config.tg_system_prompt
+        if agent.telegram_entrypoint_prompt:
+            entrypoint_prompt = "\n\n" + agent.telegram_entrypoint_prompt
+    elif entrypoint == AuthorType.XMTP.value:
+        if config.xmtp_system_prompt:
+            entrypoint_prompt = "\n\n" + config.xmtp_system_prompt
+        if agent.xmtp_entrypoint_prompt:
+            entrypoint_prompt = "\n\n" + agent.xmtp_entrypoint_prompt
+    elif entrypoint == AuthorType.TRIGGER.value:
+        entrypoint_prompt = "\n\n" + _build_autonomous_task_prompt(agent, context)
 
     # Process with admin LLM skill control if enabled
     if entrypoint_prompt and config.admin_llm_skill_control:
@@ -406,7 +396,7 @@ def create_formatted_prompt_function(agent: Agent, agent_data: AgentData) -> Cal
         entrypoint_prompt = await build_entrypoint_prompt(agent, context)
         if entrypoint_prompt:
             final_system_prompt = (
-                f"{final_system_prompt}## Entrypoint rules\n\n{entrypoint_prompt}\n\n"
+                f"{final_system_prompt}## Entrypoint rules{entrypoint_prompt}\n\n"
             )
 
         # Add user info if user_id is a valid EVM wallet address

{intentkit-0.6.12 → intentkit-0.6.13}/models/agent.py

@@ -398,6 +398,11 @@ class AgentTable(Base):
         nullable=True,
         comment="Telegram integration configuration settings",
     )
+    xmtp_entrypoint_prompt = Column(
+        String,
+        nullable=True,
+        comment="Extra prompt for xmtp entrypoint",
+    )
     # auto timestamp
     created_at = Column(
         DateTime(timezone=True),
@@ -628,7 +633,7 @@ class AgentUpdate(BaseModel):
         str,
         PydanticField(
             default="gpt-5-mini",
-            description="AI model identifier to be used by this agent for processing requests. Available models: gpt-4o, gpt-4o-mini, deepseek-chat, deepseek-reasoner, grok-2, eternalai, reigent, venice-uncensored",
+            description="AI model identifier to be used by this agent for processing requests.",
             json_schema_extra={
                 "x-group": "ai",
             },
@@ -771,7 +776,7 @@ class AgentUpdate(BaseModel):
         ),
     ]
     wallet_provider: Annotated[
-        Optional[Literal["cdp"]],
+        Optional[Literal["cdp", "readonly"]],
         PydanticField(
             default="cdp",
             description="Provider of the agent's wallet",
@@ -780,6 +785,13 @@ class AgentUpdate(BaseModel):
             },
         ),
     ]
+    readonly_wallet_address: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Address of the agent's wallet, only used when wallet_provider is readonly. Agent will not be able to sign transactions.",
+        ),
+    ]
     network_id: Annotated[
         Optional[
             Literal[
@@ -827,70 +839,49 @@ class AgentUpdate(BaseModel):
             },
         ),
     ]
-    # if twitter_enabled, the twitter_entrypoint will be enabled, twitter_config will be checked
-    twitter_entrypoint_enabled: Annotated[
+    # if telegram_entrypoint_enabled, the telegram_entrypoint_enabled will be enabled, telegram_config will be checked
+    telegram_entrypoint_enabled: Annotated[
         Optional[bool],
         PydanticField(
             default=False,
-            description="Dangerous, reply all mentions from x.com",
+            description="Whether the agent can play telegram bot",
             json_schema_extra={
                 "x-group": "entrypoint",
             },
         ),
     ]
-    twitter_entrypoint_prompt: Annotated[
+    telegram_entrypoint_prompt: Annotated[
         Optional[str],
         PydanticField(
             default=None,
-            description="Extra prompt for twitter entrypoint",
+            description="Extra prompt for telegram entrypoint",
             max_length=10000,
             json_schema_extra={
                 "x-group": "entrypoint",
             },
         ),
     ]
-    twitter_config: Annotated[
+    telegram_config: Annotated[
         Optional[dict],
         PydanticField(
             default=None,
-            description="You must use your own key for twitter entrypoint, it is separated from twitter skills",
-            json_schema_extra={
-                "x-group": "entrypoint",
-            },
-        ),
-    ]
-    # if telegram_entrypoint_enabled, the telegram_entrypoint_enabled will be enabled, telegram_config will be checked
-    telegram_entrypoint_enabled: Annotated[
-        Optional[bool],
-        PydanticField(
-            default=False,
-            description="Whether the agent can play telegram bot",
+            description="Telegram integration configuration settings",
             json_schema_extra={
                 "x-group": "entrypoint",
             },
         ),
     ]
-    telegram_entrypoint_prompt: Annotated[
+    xmtp_entrypoint_prompt: Annotated[
         Optional[str],
         PydanticField(
             default=None,
-            description="Extra prompt for telegram entrypoint",
+            description="Extra prompt for xmtp entrypoint, xmtp support is in beta",
             max_length=10000,
             json_schema_extra={
                 "x-group": "entrypoint",
             },
         ),
     ]
-    telegram_config: Annotated[
-        Optional[dict],
-        PydanticField(
-            default=None,
-            description="Telegram integration configuration settings",
-            json_schema_extra={
-                "x-group": "entrypoint",
-            },
-        ),
-    ]
 
     @field_validator("purpose", "personality", "principles", "prompt", "prompt_append")
     @classmethod
@@ -1658,7 +1649,7 @@ class AgentResponse(BaseModel):
         ),
     ]
     wallet_provider: Annotated[
-        Optional[Literal["cdp"]],
+        Optional[Literal["cdp", "readonly"]],
         PydanticField(
             default="cdp",
             description="Provider of the agent's wallet",

{intentkit-0.6.12 → intentkit-0.6.13}/models/agent_schema.json

@@ -715,10 +715,11 @@
       "type": "string",
       "description": "Provider of the agent's wallet",
       "enum": [
-        "cdp"
+        "cdp",
+        "readonly"
       ],
       "default": "cdp",
-      "x-group": "internal"
+      "x-group": "onchain"
     },
     "network_id": {
       "title": "Network ID",
@@ -741,5 +742,26 @@
       "x-group": "internal"
     }
   },
-  "additionalProperties": false
+  "additionalProperties": false,
+  "if": {
+    "properties": {
+      "wallet_provider": {
+        "const": "readonly"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "readonly_wallet_address": {
+        "title": "Readonly Wallet Address",
+        "type": "string",
+        "description": "Wallet address for readonly wallet provider",
+        "maxLength": 100,
+        "x-group": "onchain"
+      }
+    },
+    "required": [
+      "readonly_wallet_address"
+    ]
+  }
 }

{intentkit-0.6.12 → intentkit-0.6.13}/models/chat.py

@@ -45,6 +45,7 @@ class AuthorType(str, Enum):
     WEB = "web"
     SYSTEM = "system"
     API = "api"
+    XMTP = "xmtp"
 
 
 class ChatMessageAttachment(TypedDict):

{intentkit-0.6.12 → intentkit-0.6.13}/pyproject.toml

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

intentkit-0.6.12/core/api.py

@@ -1,40 +0,0 @@
-"""Core API Router.
-
-This module provides the core API endpoints for agent execution and management.
-"""
-
-from typing import Annotated
-
-from fastapi import APIRouter, Body
-from pydantic import AfterValidator
-
-from intentkit.core.engine import execute_agent
-from intentkit.models.chat import ChatMessage, ChatMessageCreate
-
-core_router = APIRouter(prefix="/core", tags=["Core"])
-
-
-@core_router.post("/execute", response_model=list[ChatMessage])
-async def execute(
-    message: Annotated[
-        ChatMessageCreate, AfterValidator(ChatMessageCreate.model_validate)
-    ] = Body(
-        ChatMessageCreate,
-        description="The chat message containing agent_id, chat_id and message content",
-    ),
-) -> list[ChatMessage]:
-    """Execute an agent with the given input and return response lines.
-
-    **Request Body:**
-    * `message` - The chat message containing agent_id, chat_id and message content
-
-    **Returns:**
-    * `list[ChatMessage]` - Formatted response lines from agent execution
-
-    **Raises:**
-    * `HTTPException`:
-        - 400: If input parameters are invalid
-        - 404: If agent not found
-        - 500: For other server-side errors
-    """
-    return await execute_agent(message)

intentkit-0.6.12/core/client.py

@@ -1,45 +0,0 @@
-"""Core Client Module.
-
-This module provides client functions for core API endpoints with environment-aware routing.
-"""
-
-import httpx
-
-from intentkit.config.config import config
-from intentkit.core.engine import execute_agent as local_execute_agent
-from intentkit.models.chat import ChatMessage, ChatMessageCreate
-
-
-async def execute_agent(
-    message: ChatMessageCreate, debug: bool = False
-) -> list[ChatMessage]:
-    """Execute an agent with environment-aware routing.
-
-    In local environment, directly calls the local execute_agent function.
-    In other environments, makes HTTP request to the core API endpoint.
-
-    Args:
-        message (ChatMessage): The chat message containing agent_id, chat_id and message content
-        debug (bool): Enable debug mode
-
-    Returns:
-        list[ChatMessage]: Formatted response lines from agent execution
-
-    Raises:
-        HTTPException: For API errors (in non-local environment)
-        Exception: For other execution errors
-    """
-    if config.env == "local":
-        return await local_execute_agent(message, debug)
-
-    # Make HTTP request in non-local environment
-    url = f"{config.internal_base_url}/core/execute"
-    async with httpx.AsyncClient() as client:
-        response = await client.post(
-            url,
-            json=message.model_dump(mode="json"),
-            timeout=180,
-        )
-    response.raise_for_status()
-    json_data = response.json()
-    return [ChatMessage.model_validate(msg) for msg in json_data]