intentkit 0.6.9.dev2__py3-none-any.whl → 0.6.10__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.6.9-dev2"
+__version__ = "0.6.10"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/abstracts/graph.py

@@ -1,7 +1,11 @@
+import asyncio
 from enum import Enum
-from typing import Any, Callable, Dict, NotRequired
+from typing import Any, Dict, Literal, NotRequired, Optional
 
 from langgraph.prebuilt.chat_agent_executor import AgentState as BaseAgentState
+from pydantic import BaseModel
+
+from intentkit.models.agent import Agent
 
 
 class AgentError(str, Enum):
@@ -22,4 +26,15 @@ class AgentState(BaseAgentState):
     __extra__: NotRequired[Dict[str, Any]]
 
 
-MemoryManager = Callable[[AgentState], AgentState]
+class AgentContext(BaseModel):
+    agent_id: str
+    chat_id: str
+    user_id: Optional[str] = None
+    app_id: Optional[str] = None
+    entrypoint: Literal["web", "twitter", "telegram", "trigger", "api"]
+    is_private: bool
+    payer: Optional[str] = None
+
+    @property
+    def agent(self) -> Agent:
+        return asyncio.run(Agent.get(self.agent_id))

intentkit/core/engine.py

@@ -27,15 +27,15 @@ from langchain_core.messages import (
     HumanMessage,
 )
 from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnableConfig
 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
 
-from intentkit.abstracts.graph import AgentError, AgentState
+from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
 from intentkit.config.config import config
 from intentkit.core.credit import expense_message, expense_skill
 from intentkit.core.node import PreModelNode, post_model_node
@@ -201,11 +201,13 @@ async def create_agent(
     prompt_temp = ChatPromptTemplate.from_messages(prompt_array)
 
     async def formatted_prompt(
-        state: AgentState, config: RunnableConfig
+        state: AgentState, runtime: Runtime[AgentContext]
     ) -> list[BaseMessage]:
         final_system_prompt = escaped_prompt
-        if config.get("configurable") and config["configurable"].get("entrypoint"):
-            entrypoint = config["configurable"]["entrypoint"]
+        context = runtime.context
+        logger.debug(f"formatted_prompt, context: {context}")
+        if context.entrypoint:
+            entrypoint = context.entrypoint
             entrypoint_prompt = None
             if (
                 agent.twitter_entrypoint_enabled
@@ -222,11 +224,7 @@ async def create_agent(
                 entrypoint_prompt = agent.telegram_entrypoint_prompt
                 logger.debug("telegram entrypoint prompt added")
             elif entrypoint == AuthorType.TRIGGER.value:
-                task_id = (
-                    config["configurable"]
-                    .get("chat_id", "")
-                    .removeprefix("autonomous-")
-                )
+                task_id = context.chat_id.removeprefix("autonomous-")
                 # Find the autonomous task by task_id
                 autonomous_task = None
                 if agent.autonomous:
@@ -263,20 +261,15 @@ async def create_agent(
             if entrypoint_prompt:
                 entrypoint_prompt = await explain_prompt(entrypoint_prompt)
                 final_system_prompt = f"{final_system_prompt}## Entrypoint rules\n\n{entrypoint_prompt}\n\n"
-        if config.get("configurable"):
-            final_system_prompt = f"{final_system_prompt}## Internal Info\n\n"
-            "These are for your internal use. You can use them when querying or storing data, "
-            "but please do not directly share this information with users.\n\n"
-            chat_id = config["configurable"].get("chat_id")
-            if chat_id:
-                final_system_prompt = f"{final_system_prompt}chat_id: {chat_id}\n\n"
-            user_id = config["configurable"].get("user_id")
-            if user_id:
-                final_system_prompt = f"{final_system_prompt}user_id: {user_id}\n\n"
+        final_system_prompt = f"{final_system_prompt}## Internal Info\n\n"
+        "These are for your internal use. You can use them when querying or storing data, "
+        "but please do not directly share this information with users.\n\n"
+        final_system_prompt = f"{final_system_prompt}chat_id: {context.chat_id}\n\n"
+        if context.user_id:
+            final_system_prompt = f"{final_system_prompt}user_id: {context.user_id}\n\n"
         system_prompt = [("system", final_system_prompt)]
         return prompt_temp.invoke(
-            {"messages": state["messages"], "system_prompt": system_prompt},
-            config,
+            {"messages": state["messages"], "system_prompt": system_prompt}
         )
 
     # log final prompt and all skills
@@ -304,6 +297,7 @@ async def create_agent(
         pre_model_hook=pre_model_hook,
         post_model_hook=post_model_node if config.payment_enabled else None,
         state_schema=AgentState,
+        context_schema=AgentContext,
         checkpointer=memory,
         debug=config.debug_checkpoint,
         name=agent.id,
@@ -585,22 +579,27 @@ async def stream_agent(message: ChatMessageCreate):
     thread_id = f"{input.agent_id}-{input.chat_id}"
     stream_config = {
         "configurable": {
-            "agent_id": agent.id,
             "thread_id": thread_id,
-            "chat_id": input.chat_id,
-            "user_id": input.user_id,
-            "app_id": input.app_id,
-            "entrypoint": input.author_type,
-            "is_private": is_private,
-            "payer": payer if payment_enabled else None,
         },
         "recursion_limit": recursion_limit,
     }
 
+    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,
+        is_private=is_private,
+        payer=payer if payment_enabled else None,
+    )
+
     # run
     cached_tool_step = None
     try:
-        async for chunk in executor.astream({"messages": messages}, stream_config):
+        async for chunk in executor.astream(
+            {"messages": messages}, context=context, config=stream_config
+        ):
             this_time = time.perf_counter()
             logger.debug(f"stream chunk: {chunk}", extra={"thread_id": thread_id})
             if "agent" in chunk and "messages" in chunk["agent"]:
@@ -728,6 +727,26 @@ async def stream_agent(message: ChatMessageCreate):
                                     skill_call["response"] = textwrap.shorten(
                                         str(msg.content), width=1000, placeholder="..."
                                     )
+                                if msg.artifact:
+                                    artifact_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,
+                                        author_type=AuthorType.SKILL,
+                                        model=agent.model,
+                                        thread_type=input.author_type,
+                                        reply_to=input.id,
+                                        message="",
+                                        attachments=msg.artifact,
+                                        time_cost=this_time - last,
+                                    )
+                                    artifact_message = (
+                                        await artifact_message_create.save()
+                                    )
+                                    yield artifact_message
+                                    last = this_time
                             skill_calls.append(skill_call)
                             break
                 skill_message_create = ChatMessageCreate(

intentkit/core/node.py

@@ -11,8 +11,8 @@ from langchain_core.messages import (
     ToolMessage,
 )
 from langchain_core.messages.utils import count_tokens_approximately, trim_messages
-from langchain_core.runnables import RunnableConfig
 from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.runtime import get_runtime
 from langgraph.utils.runnable import RunnableCallable
 from langmem.short_term.summarization import (
     DEFAULT_EXISTING_SUMMARY_PROMPT,
@@ -21,9 +21,8 @@ from langmem.short_term.summarization import (
     SummarizationResult,
     asummarize_messages,
 )
-from pydantic import BaseModel
 
-from intentkit.abstracts.graph import AgentError, AgentState
+from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
 from intentkit.core.credit import skill_cost
 from intentkit.models.agent import Agent
 from intentkit.models.credit import CreditAccount, OwnerType
@@ -108,11 +107,7 @@ class PreModelNode(RunnableCallable):
     def _func(self, AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(
-        self,
-        input: AgentState,
-        config: RunnableConfig,
-    ) -> dict[str, Any]:
+    async def _afunc(self, input: AgentState) -> dict[str, Any]:
         messages, context = self._parse_input(input)
         try:
             _validate_chat_history(messages)
@@ -180,28 +175,23 @@ class PostModelNode(RunnableCallable):
         super().__init__(self._func, self._afunc, name="post_model_node", trace=False)
         self.func_accepts_config = True
 
-    def _func(self, input: dict[str, Any] | BaseModel) -> dict[str, Any]:
+    def _func(self, input: AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(
-        self,
-        input: AgentState,
-        config: RunnableConfig,
-    ) -> dict[str, Any]:
-        logger.debug(f"Running PostModelNode, input: {input}, config: {config}")
+    async def _afunc(self, input: AgentState) -> dict[str, Any]:
+        runtime = get_runtime(AgentContext)
+        context = runtime.context
+        logger.debug(f"Running PostModelNode, input: {input}, context: {context}")
         state_update = {}
         messages = input.get("messages")
         if messages is None or not isinstance(messages, list) or len(messages) == 0:
             raise ValueError("Missing required field `messages` in the input.")
-        cfg = config.get("configurable")
-        if not config:
-            raise ValueError("Missing required field `configurable` in the config.")
-        payer = cfg.get("payer")
+        payer = context.payer
         if not payer:
             return state_update
         logger.debug(f"last: {messages[-1]}")
         msg = messages[-1]
-        agent_id = cfg.get("agent_id")
+        agent_id = context.agent_id
         agent = await Agent.get(agent_id)
         account = await CreditAccount.get_or_create(OwnerType.USER, payer)
         if hasattr(msg, "tool_calls") and msg.tool_calls:

intentkit/models/agent.py

@@ -4,8 +4,10 @@ import re
 import textwrap
 from datetime import datetime, timezone
 from decimal import Decimal
+from pathlib import Path
 from typing import Annotated, Any, Dict, List, Literal, Optional
 
+import jsonref
 import yaml
 from cron_validator import CronValidator
 from epyxid import XID
@@ -13,7 +15,8 @@ from fastapi import HTTPException
 from intentkit.models.agent_data import AgentData
 from intentkit.models.base import Base
 from intentkit.models.db import get_session
-from intentkit.models.llm import LLMModelInfo
+from intentkit.models.llm import LLMModelInfo, LLMModelInfoTable, LLMProvider
+from intentkit.models.skill import SkillTable
 from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 from pydantic import Field as PydanticField
 from pydantic.json_schema import SkipJsonSchema
@@ -28,6 +31,7 @@ from sqlalchemy import (
     select,
 )
 from sqlalchemy.dialects.postgresql import JSON, JSONB
+from sqlalchemy.ext.asyncio import AsyncSession
 
 logger = logging.getLogger(__name__)
 
@@ -293,7 +297,7 @@ class AgentTable(Base):
     model = Column(
         String,
         nullable=True,
-        default="gpt-4.1-mini",
+        default="gpt-5-mini",
         comment="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",
     )
     prompt = Column(
@@ -623,7 +627,7 @@ class AgentUpdate(BaseModel):
     model: Annotated[
         str,
         PydanticField(
-            default="gpt-4.1-mini",
+            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",
             json_schema_extra={
                 "x-group": "ai",
@@ -914,38 +918,38 @@ class AgentUpdate(BaseModel):
         if not self.autonomous:
             return
 
-        for config in self.autonomous:
+        for autonomous_config in self.autonomous:
             # Check that exactly one scheduling method is provided
-            if not config.minutes and not config.cron:
+            if not autonomous_config.minutes and not autonomous_config.cron:
                 raise HTTPException(
                     status_code=400, detail="either minutes or cron must have a value"
                 )
 
-            if config.minutes and config.cron:
+            if autonomous_config.minutes and autonomous_config.cron:
                 raise HTTPException(
                     status_code=400, detail="only one of minutes or cron can be set"
                 )
 
             # Validate minimum interval of 5 minutes
-            if config.minutes and config.minutes < 5:
+            if autonomous_config.minutes and autonomous_config.minutes < 5:
                 raise HTTPException(
                     status_code=400,
                     detail="The shortest execution interval is 5 minutes",
                 )
 
             # Validate cron expression to ensure interval is at least 5 minutes
-            if config.cron:
+            if autonomous_config.cron:
                 # First validate the cron expression format using cron-validator
 
                 try:
-                    CronValidator.parse(config.cron)
+                    CronValidator.parse(autonomous_config.cron)
                 except ValueError:
                     raise HTTPException(
                         status_code=400,
-                        detail=f"Invalid cron expression format: {config.cron}",
+                        detail=f"Invalid cron expression format: {autonomous_config.cron}",
                     )
 
-                parts = config.cron.split()
+                parts = autonomous_config.cron.split()
                 if len(parts) < 5:
                     raise HTTPException(
                         status_code=400, detail="Invalid cron expression format"
@@ -1285,6 +1289,206 @@ class Agent(AgentCreate):
                 return None
             return cls.model_validate(item)
 
+    def skill_config(self, category: str) -> Dict[str, Any]:
+        return self.skills.get(category, {}) if self.skills else {}
+
+    @staticmethod
+    def _is_agent_owner_only_skill(skill_schema: Dict[str, Any]) -> bool:
+        """Check if a skill requires agent owner API keys only based on its resolved schema."""
+        if (
+            skill_schema
+            and "properties" in skill_schema
+            and "api_key_provider" in skill_schema["properties"]
+        ):
+            api_key_provider = skill_schema["properties"]["api_key_provider"]
+            if "enum" in api_key_provider and api_key_provider["enum"] == [
+                "agent_owner"
+            ]:
+                return True
+        return False
+
+    @classmethod
+    async def get_json_schema(
+        cls,
+        db: AsyncSession = None,
+        filter_owner_api_skills: bool = False,
+        admin_llm_skill_control: bool = True,
+    ) -> Dict:
+        """Get the JSON schema for Agent model with all $ref references resolved.
+
+        This is the shared function that handles admin configuration filtering
+        for both the API endpoint and agent generation.
+
+        Args:
+            db: Database session (optional, will create if not provided)
+            filter_owner_api_skills: Whether to filter out skills that require agent owner API keys
+            admin_llm_skill_control: Whether to enable admin LLM and skill control features
+
+        Returns:
+            Dict containing the complete JSON schema for the Agent model
+        """
+        # Get database session if not provided
+        if db is None:
+            async with get_session() as session:
+                return await cls.get_json_schema(
+                    session, filter_owner_api_skills, admin_llm_skill_control
+                )
+
+        # Get the schema file path relative to this file
+        current_dir = Path(__file__).parent
+        agent_schema_path = current_dir / "agent_schema.json"
+
+        base_uri = f"file://{agent_schema_path}"
+        with open(agent_schema_path) as f:
+            schema = jsonref.load(f, base_uri=base_uri, proxies=False, lazy_load=False)
+
+            # Get the model property from the schema
+            model_property = schema.get("properties", {}).get("model", {})
+
+            if admin_llm_skill_control:
+                # Process model property - use LLMModelInfo as primary source
+                if model_property:
+                    # Query all LLM models from the database
+                    stmt = select(LLMModelInfoTable).where(LLMModelInfoTable.enabled)
+                    result = await db.execute(stmt)
+                    models = result.scalars().all()
+
+                    # Create new lists based on LLMModelInfo
+                    new_enum = []
+                    new_enum_title = []
+                    new_enum_category = []
+                    new_enum_support_skill = []
+
+                    # Process each model from database
+                    for model in models:
+                        model_info = LLMModelInfo.model_validate(model)
+
+                        # Add model ID to enum
+                        new_enum.append(model_info.id)
+
+                        # Add model name as title
+                        new_enum_title.append(model_info.name)
+
+                        # Add provider display name as category
+                        provider = (
+                            LLMProvider(model_info.provider)
+                            if isinstance(model_info.provider, str)
+                            else model_info.provider
+                        )
+                        new_enum_category.append(provider.display_name())
+
+                        # Add skill support information
+                        new_enum_support_skill.append(model_info.supports_skill_calls)
+
+                    # Update the schema with the new lists constructed from LLMModelInfo
+                    model_property["enum"] = new_enum
+                    model_property["x-enum-title"] = new_enum_title
+                    model_property["x-enum-category"] = new_enum_category
+                    model_property["x-support-skill"] = new_enum_support_skill
+
+                    # If the default model is not in the new enum, update it if possible
+                    if (
+                        "default" in model_property
+                        and model_property["default"] not in new_enum
+                        and new_enum
+                    ):
+                        model_property["default"] = new_enum[0]
+
+                # Process skills property
+                skills_property = schema.get("properties", {}).get("skills", {})
+                skills_properties = skills_property.get("properties", {})
+
+                if skills_properties:
+                    # Load all skills from the database
+                    # Query all skills grouped by category with enabled status
+                    stmt = select(
+                        SkillTable.category,
+                        func.bool_or(SkillTable.enabled).label("any_enabled"),
+                    ).group_by(SkillTable.category)
+                    result = await db.execute(stmt)
+                    category_status = {row.category: row.any_enabled for row in result}
+
+                    # Query all skills with their price levels for adding x-price-level fields
+                    skills_stmt = select(
+                        SkillTable.category,
+                        SkillTable.config_name,
+                        SkillTable.price_level,
+                        SkillTable.enabled,
+                    ).where(SkillTable.enabled)
+                    skills_result = await db.execute(skills_stmt)
+                    skills_data = {}
+                    category_price_levels = {}
+
+                    for row in skills_result:
+                        if row.category not in skills_data:
+                            skills_data[row.category] = {}
+                            category_price_levels[row.category] = []
+
+                        if row.config_name:
+                            skills_data[row.category][row.config_name] = row.price_level
+
+                        if row.price_level is not None:
+                            category_price_levels[row.category].append(row.price_level)
+
+                    # Calculate average price levels for categories
+                    category_avg_price_levels = {}
+                    for category, price_levels in category_price_levels.items():
+                        if price_levels:
+                            avg_price_level = int(sum(price_levels) / len(price_levels))
+                            category_avg_price_levels[category] = avg_price_level
+
+                    # Create a copy of keys to avoid modifying during iteration
+                    skill_keys = list(skills_properties.keys())
+
+                    # Process each skill in the schema
+                    for skill_category in skill_keys:
+                        if skill_category not in category_status:
+                            # If category not found in database, remove it from schema
+                            skills_properties.pop(skill_category, None)
+                        elif not category_status[skill_category]:
+                            # If category exists but all skills are disabled, remove it
+                            skills_properties.pop(skill_category, None)
+                        elif filter_owner_api_skills and cls._is_agent_owner_only_skill(
+                            skills_properties[skill_category]
+                        ):
+                            # If filtering owner API skills and this skill requires it, remove it
+                            skills_properties.pop(skill_category, None)
+                            logger.info(
+                                f"Filtered out skill '{skill_category}' from auto-generation: requires agent owner API key"
+                            )
+                        else:
+                            # Add x-avg-price-level to category level
+                            if skill_category in category_avg_price_levels:
+                                skills_properties[skill_category][
+                                    "x-avg-price-level"
+                                ] = category_avg_price_levels[skill_category]
+
+                            # Add x-price-level to individual skill states
+                            if skill_category in skills_data:
+                                skill_states = (
+                                    skills_properties[skill_category]
+                                    .get("properties", {})
+                                    .get("states", {})
+                                    .get("properties", {})
+                                )
+                                for state_name, state_config in skill_states.items():
+                                    if (
+                                        state_name in skills_data[skill_category]
+                                        and skills_data[skill_category][state_name]
+                                        is not None
+                                    ):
+                                        state_config["x-price-level"] = skills_data[
+                                            skill_category
+                                        ][state_name]
+
+            # Log the changes for debugging
+            logger.debug(
+                f"Schema processed with LLM and skill controls enabled: {admin_llm_skill_control}, "
+                f"filtered owner API skills: {filter_owner_api_skills}"
+            )
+
+            return schema
+
 
 class AgentResponse(BaseModel):
     """Response model for Agent API."""

intentkit/models/agent_schema.json

@@ -491,6 +491,10 @@
           "title": "X",
           "$ref": "../skills/twitter/schema.json"
         },
+        "xmtp": {
+          "title": "XMTP",
+          "$ref": "../skills/xmtp/schema.json"
+        },
         "chainlist": {
           "title": "Chainlist RPC Endpoints",
           "$ref": "../skills/chainlist/schema.json"

intentkit/models/chat.py

@@ -31,6 +31,7 @@ class ChatMessageAttachmentType(str, Enum):
     LINK = "link"
     IMAGE = "image"
     FILE = "file"
+    XMTP = "xmtp"
 
 
 class AuthorType(str, Enum):
@@ -61,13 +62,20 @@ class ChatMessageAttachment(TypedDict):
         ),
     ]
     url: Annotated[
-        str,
+        Optional[str],
         Field(
             ...,
             description="URL of the attachment",
             examples=["https://example.com/image.jpg"],
         ),
     ]
+    json: Annotated[
+        Optional[dict],
+        Field(
+            None,
+            description="JSON data of the attachment",
+        ),
+    ]
 
 
 class ChatMessageSkillCall(TypedDict):

intentkit/models/llm.py

@@ -266,6 +266,59 @@ AVAILABLE_MODELS = {
         supports_frequency_penalty=False,
         supports_presence_penalty=False,
     ),
+    "gpt-5-nano": LLMModelInfo(
+        id="gpt-5-nano",
+        name="GPT-5 Nano",
+        provider=LLMProvider.OPENAI,
+        input_price=Decimal("0.05"),  # per 1M input tokens
+        output_price=Decimal("0.4"),  # per 1M output tokens
+        context_length=400000,
+        output_length=128000,
+        intelligence=3,
+        speed=5,
+        supports_image_input=True,
+        supports_skill_calls=True,
+        supports_structured_output=True,
+        supports_temperature=False,
+        supports_frequency_penalty=False,
+        supports_presence_penalty=False,
+    ),
+    "gpt-5-mini": LLMModelInfo(
+        id="gpt-5-mini",
+        name="GPT-5 Mini",
+        provider=LLMProvider.OPENAI,
+        input_price=Decimal("0.25"),  # per 1M input tokens
+        output_price=Decimal("2"),  # per 1M output tokens
+        context_length=400000,
+        output_length=128000,
+        intelligence=4,
+        speed=4,
+        supports_image_input=True,
+        supports_skill_calls=True,
+        supports_structured_output=True,
+        supports_search=True,
+        supports_temperature=False,
+        supports_frequency_penalty=False,
+        supports_presence_penalty=False,
+    ),
+    "gpt-5": LLMModelInfo(
+        id="gpt-5",
+        name="GPT-5",
+        provider=LLMProvider.OPENAI,
+        input_price=Decimal("1.25"),  # per 1M input tokens
+        output_price=Decimal("10.00"),  # per 1M output tokens
+        context_length=400000,
+        output_length=128000,
+        intelligence=5,
+        speed=3,
+        supports_image_input=True,
+        supports_skill_calls=True,
+        supports_structured_output=True,
+        supports_search=True,
+        supports_temperature=False,
+        supports_frequency_penalty=False,
+        supports_presence_penalty=False,
+    ),
     "gpt-4.1-nano": LLMModelInfo(
         id="gpt-4.1-nano",
         name="GPT-4.1 Nano",