intentkit 0.8.25.dev1__tar.gz → 0.8.26__tar.gz

{intentkit-0.8.25.dev1 → intentkit-0.8.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.8.25.dev1
+Version: 0.8.26
 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.8.25.dev1 → intentkit-0.8.26}/intentkit/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.8.25-dev1"
+__version__ = "0.8.26"
 __author__ = "Ruihua"
 __email__ = "ruihua@crestal.network"
 

{intentkit-0.8.25.dev1 → intentkit-0.8.26}/intentkit/core/engine.py

@@ -67,6 +67,29 @@ _agents: dict[str, CompiledStateGraph] = {}
 _agents_updated: dict[str, datetime] = {}
 
 
+def _extract_text_content(content: object) -> str:
+    if isinstance(content, list):
+        texts: list[str] = []
+        for item in content:
+            if isinstance(item, dict):
+                t = item.get("text")
+                ty = item.get("type")
+                if t is not None and (ty == "text" or ty is None):
+                    texts.append(t)
+            elif isinstance(item, str):
+                texts.append(item)
+        return "".join(texts)
+    if isinstance(content, dict):
+        if content.get("type") == "text" and "text" in content:
+            return content["text"]
+        if "text" in content:
+            return content["text"]
+        return ""
+    if isinstance(content, str):
+        return content
+    return ""
+
+
 async def build_agent(
     agent: Agent, agent_data: AgentData, custom_skills: list[BaseTool] = []
 ) -> CompiledStateGraph:
@@ -149,8 +172,8 @@ async def build_agent(
                 if llm_model.info.provider == LLMProvider.OPENAI:
                     tools.append({"type": "web_search"})
                     private_tools.append({"type": "web_search"})
-                    if agent.model.startswith("gpt-5-"):
-                        llm_params["reasoning_effort"] = "low"
+                    if llm_model.info.model_name == "gpt-5-mini":
+                        llm_params["reasoning_effort"] = "medium"
                 if llm_model.info.provider == LLMProvider.XAI:
                     llm_params["search_parameters"] = {"mode": "auto"}
             # TODO: else use a search skill
@@ -431,31 +454,30 @@ async def stream_agent_raw(
 
     # super mode
     recursion_limit = 30
-    if re.search(r"\b@super\b", input_message):
+    if re.search(r"@super\b", input_message) or user_message.super_mode:
         recursion_limit = 300
         # Remove @super from the message
-        input_message = re.sub(r"\b@super\b", "", input_message).strip()
+        input_message = re.sub(r"@super\b", "", input_message).strip()
 
     # llm native search
-    search = False
-    if re.search(r"\b@search\b", input_message) or re.search(
-        r"\b@web\b", input_message
-    ):
+    search = user_message.search_mode if user_message.search_mode is not None else False
+    if re.search(r"@search\b", input_message) or re.search(r"@web\b", input_message):
         search = True
         if model.supports_search:
             input_message = re.sub(
-                r"\b@search\b",
+                r"@search\b",
                 "(You have native search tool, you can use it to get more recent information)",
                 input_message,
             ).strip()
             input_message = re.sub(
-                r"\b@web\b",
+                r"@web\b",
                 "(You have native search tool, you can use it to get more recent information)",
                 input_message,
             ).strip()
         else:
-            input_message = re.sub(r"\b@search\b", "", input_message).strip()
-            input_message = re.sub(r"\b@web\b", "", input_message).strip()
+            search = False
+            input_message = re.sub(r"@search\b", "", input_message).strip()
+            input_message = re.sub(r"@web\b", "", input_message).strip()
 
     # content to llm
     messages = [
@@ -526,16 +548,7 @@ async def stream_agent_raw(
                     # tool calls, save for later use, if it is deleted by post_model_hook, will not be used.
                     cached_tool_step = msg
                 if hasattr(msg, "content") and msg.content:
-                    content = msg.content
-                    if isinstance(msg.content, list):
-                        # in new version, content item maybe a list
-                        content = msg.content[0]
-                    if isinstance(content, dict):
-                        if "text" in content:
-                            content = content["text"]
-                        else:
-                            content = str(content)
-                            logger.error(f"unexpected content type: {content}")
+                    content = _extract_text_content(msg.content)
                     # agent message
                     chat_message_create = ChatMessageCreate(
                         id=str(XID()),

{intentkit-0.8.25.dev1 → intentkit-0.8.26}/intentkit/core/prompt.py

@@ -250,7 +250,7 @@ async def explain_prompt(message: str) -> str:
         str: The processed message with @skill patterns replaced
     """
     # Pattern to match @skill:category:config_name with word boundaries
-    pattern = r"\b@skill:([^:]+):([^\s]+)\b"
+    pattern = r"@skill:([^:]+):([^\s]+)\b"
 
     async def replace_skill_pattern(match):
         category = match.group(1)

{intentkit-0.8.25.dev1 → intentkit-0.8.26}/intentkit/models/agent.py

@@ -18,19 +18,11 @@ from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic import Field as PydanticField
 from pydantic.json_schema import SkipJsonSchema
 from pydantic.main import IncEx
-from sqlalchemy import (
-    Boolean,
-    Column,
-    DateTime,
-    Float,
-    Numeric,
-    String,
-    func,
-    select,
-)
+from sqlalchemy import Boolean, DateTime, Float, Numeric, String, func, select
 from sqlalchemy.dialects.postgresql import JSON, JSONB
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
 
 from intentkit.models.agent_data import AgentData
 from intentkit.models.base import Base
@@ -184,62 +176,62 @@ class AgentUserInputColumns:
     __abstract__ = True
 
     # Basic information fields from AgentCore
-    name = Column(
+    name: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Display name of the agent",
     )
-    picture = Column(
+    picture: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Picture of the agent",
     )
-    purpose = Column(
+    purpose: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Purpose or role of the agent",
     )
-    personality = Column(
+    personality: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Personality traits of the agent",
     )
-    principles = Column(
+    principles: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Principles or values of the agent",
     )
 
     # AI model configuration fields from AgentCore
-    model = Column(
+    model: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         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(
+    prompt: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Base system prompt that defines the agent's behavior and capabilities",
     )
-    prompt_append = Column(
+    prompt_append: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Additional system prompt that has higher priority than the base prompt",
     )
-    temperature = Column(
+    temperature: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         default=0.7,
         comment="Controls response randomness (0.0~2.0). Higher values increase creativity but may reduce accuracy. For rigorous tasks, use lower values.",
     )
-    frequency_penalty = Column(
+    frequency_penalty: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         default=0.0,
         comment="Controls repetition in responses (-2.0~2.0). Higher values reduce repetition, lower values allow more repetition.",
     )
-    presence_penalty = Column(
+    presence_penalty: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         default=0.0,
@@ -247,17 +239,17 @@ class AgentUserInputColumns:
     )
 
     # Wallet and network configuration fields from AgentCore
-    wallet_provider = Column(
+    wallet_provider: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Provider of the agent's wallet",
     )
-    readonly_wallet_address = Column(
+    readonly_wallet_address: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Readonly wallet address of the agent",
     )
-    network_id = Column(
+    network_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         default="base-mainnet",
@@ -265,52 +257,52 @@ class AgentUserInputColumns:
     )
 
     # Skills configuration from AgentCore
-    skills = Column(
+    skills: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Dict of skills and their corresponding configurations",
     )
 
     # Additional fields from AgentUserInput
-    short_term_memory_strategy = Column(
+    short_term_memory_strategy: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         default="trim",
         comment="Strategy for managing short-term memory when context limit is reached. 'trim' removes oldest messages, 'summarize' creates summaries.",
     )
-    autonomous = Column(
+    autonomous: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Autonomous agent configurations",
     )
-    telegram_entrypoint_enabled = Column(
+    telegram_entrypoint_enabled: Mapped[bool | None] = mapped_column(
         Boolean,
         nullable=True,
         default=False,
         comment="Whether the agent can receive events from Telegram",
     )
-    telegram_entrypoint_prompt = Column(
+    telegram_entrypoint_prompt: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Extra prompt for telegram entrypoint",
     )
-    telegram_config = Column(
+    telegram_config: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Telegram integration configuration settings",
     )
-    discord_entrypoint_enabled = Column(
+    discord_entrypoint_enabled: Mapped[bool | None] = mapped_column(
         Boolean,
         nullable=True,
         default=False,
         comment="Whether the agent can receive events from Discord",
     )
-    discord_config = Column(
+    discord_config: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Discord integration configuration settings",
     )
-    xmtp_entrypoint_prompt = Column(
+    xmtp_entrypoint_prompt: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Extra prompt for xmtp entrypoint",
@@ -322,128 +314,128 @@ class AgentTable(Base, AgentUserInputColumns):
 
     __tablename__ = "agents"
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
         comment="Unique identifier for the agent. Must be URL-safe, containing only lowercase letters, numbers, and hyphens",
     )
-    slug = Column(
+    slug: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Slug of the agent, used for URL generation",
     )
-    owner = Column(
+    owner: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Owner identifier of the agent, used for access control",
     )
-    upstream_id = Column(
+    upstream_id: Mapped[str | None] = mapped_column(
         String,
         index=True,
         nullable=True,
         comment="Upstream reference ID for idempotent operations",
     )
-    upstream_extra = Column(
+    upstream_extra: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Additional data store for upstream use",
     )
-    version = Column(
+    version: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Version hash of the agent",
     )
-    statistics = Column(
+    statistics: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Statistics of the agent, update every 1 hour for query",
     )
-    assets = Column(
+    assets: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Assets of the agent, update every 1 hour for query",
     )
-    account_snapshot = Column(
+    account_snapshot: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Account snapshot of the agent, update every 1 hour for query",
     )
-    extra = Column(
+    extra: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Other helper data fields for query, come from agent and agent data",
     )
 
     # Fields moved from AgentUserInputColumns that are no longer in AgentUserInput
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Description of the agent, for public view, not contained in prompt",
     )
-    external_website = Column(
+    external_website: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Link of external website of the agent, if you have one",
     )
-    ticker = Column(
+    ticker: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Ticker symbol of the agent",
     )
-    token_address = Column(
+    token_address: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Token address of the agent",
     )
-    token_pool = Column(
+    token_pool: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Pool of the agent token",
     )
-    fee_percentage = Column(
+    fee_percentage: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
         comment="Fee percentage of the agent",
     )
-    example_intro = Column(
+    example_intro: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Introduction for example interactions",
     )
-    examples = Column(
+    examples: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="List of example interactions for the agent",
     )
-    public_extra = Column(
+    public_extra: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Public extra data of the agent",
     )
-    deployed_at = Column(
+    deployed_at: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True),
         nullable=True,
         comment="Timestamp when the agent was deployed",
     )
-    public_info_updated_at = Column(
+    public_info_updated_at: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True),
         nullable=True,
         comment="Timestamp when the agent public info was last updated",
     )
-    x402_price = Column(
+    x402_price: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         comment="Price of the x402 request",
     )
 
     # auto timestamp
-    created_at = Column(
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
         comment="Timestamp when the agent was created",
     )
-    updated_at = Column(
+    updated_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
@@ -966,6 +958,7 @@ class AgentPublicInfo(BaseModel):
             le=1.0,
             json_schema_extra={
                 "x-placeholder": "Enter agent price",
+                "x-step": 0.01,
             },
         ),
     ]