intentkit 0.12.2__tar.gz → 0.12.3__tar.gz

{intentkit-0.12.2 → intentkit-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.12.2
+Version: 0.12.3
 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.12.2 → intentkit-0.12.3}/intentkit/__init__.py

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

{intentkit-0.12.2 → intentkit-0.12.3}/intentkit/core/engine.py

@@ -79,7 +79,7 @@ from intentkit.models.chat import (
     ChatMessageSkillCall,
 )
 from intentkit.models.credit import CreditAccount, OwnerType
-from intentkit.models.llm import LLMModelInfo, create_llm_model
+from intentkit.models.llm import LLMModelInfo, LLMProvider, create_llm_model
 from intentkit.models.llm_picker import pick_summarize_model
 from intentkit.models.skill import AgentSkillData, ChatSkillData
 from intentkit.models.user import User
@@ -95,6 +95,60 @@ _agents: dict[str, CompiledStateGraph[AgentState, AgentContext, Any, Any]] = {}
 _agents_updated: dict[str, datetime] = {}
 
 
+def _extract_thinking_content(msg: Any) -> str | None:
+    """Extract reasoning/thinking content from a LangChain AIMessage.
+
+    Handles multiple provider formats:
+    - additional_kwargs["reasoning_content"] (OpenRouter, DeepSeek, xAI) — string
+    - additional_kwargs["reasoning"]["summary"] (OpenAI Responses API v0 compat) — dict
+    - content list: type="reasoning" with reasoning/summary/text (langchain-core, OpenAI)
+    - content list: type="thinking" with thinking field (Anthropic, Google Gemini)
+    """
+    texts: list[str] = []
+
+    # 1. Check additional_kwargs (OpenRouter, DeepSeek, xAI, OpenAI v0)
+    kwargs = getattr(msg, "additional_kwargs", None) or {}
+    if isinstance(kwargs, dict):
+        # OpenRouter / DeepSeek / xAI: reasoning_content is a string
+        rc = kwargs.get("reasoning_content")
+        if isinstance(rc, str) and rc:
+            texts.append(rc)
+        # OpenAI Responses API v0 compat: reasoning is a dict with summary list
+        reasoning = kwargs.get("reasoning")
+        if isinstance(reasoning, dict):
+            for s in reasoning.get("summary", []):
+                if isinstance(s, dict) and s.get("text"):
+                    texts.append(s["text"])
+
+    # 2. Check content blocks
+    content = getattr(msg, "content", None)
+    if isinstance(content, list):
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            item_type = item.get("type")
+            if item_type == "reasoning":
+                # langchain-core standard: text in "reasoning" field
+                r = item.get("reasoning")
+                if isinstance(r, str) and r:
+                    texts.append(r)
+                # OpenAI Responses API: summary list
+                elif isinstance(item.get("summary"), list):
+                    for s in item["summary"]:
+                        if isinstance(s, dict) and s.get("text"):
+                            texts.append(s["text"])
+                # Fallback: direct text field
+                elif item.get("text"):
+                    texts.append(item["text"])
+            elif item_type == "thinking":
+                # Anthropic / Google Gemini: text in "thinking" field
+                t = item.get("thinking")
+                if isinstance(t, str) and t:
+                    texts.append(t)
+
+    return "\n\n".join(texts) if texts else None
+
+
 def _extract_text_content(content: object) -> str:
     if isinstance(content, list):
         texts: list[str] = []
@@ -204,19 +258,12 @@ async def build_executor(
     # add system skills to private tools
     from intentkit.core.system_skills import get_system_skills
 
-    enable_activity = (
-        agent.enable_activity if agent.enable_activity is not None else True
-    )
-    enable_post = agent.enable_post if agent.enable_post is not None else True
-    private_tools.extend(
-        get_system_skills(
-            enable_activity=enable_activity,
-            enable_post=enable_post,
-            enable_long_term_memory=agent.enable_long_term_memory or False,
-            enable_sub_agents=bool(agent.sub_agents),
-            search_internet=agent.search_internet,
-        )
-    )
+    system_skills = get_system_skills(agent)
+    # Skip read_webpage for providers that have native search capabilities
+    model_provider = llm_model.info.provider
+    if model_provider in (LLMProvider.GOOGLE, LLMProvider.OPENAI):
+        system_skills = [s for s in system_skills if s.name != "read_webpage"]
+    private_tools.extend(system_skills)
 
     # filter the duplicate tools
     tools = list(
@@ -615,6 +662,7 @@ async def stream_agent_raw(
     yielded_any = False
     raw_chunks = []
     cached_tool_step = None
+    in_tools_phase = False
     try:
         async for chunk in executor.astream(
             {"messages": messages},
@@ -680,12 +728,31 @@ async def stream_agent_raw(
                 msg = chunk["model"]["messages"][0]
                 has_tools = hasattr(msg, "tool_calls") and bool(msg.tool_calls)
                 if has_tools:
+                    in_tools_phase = True
                     cached_tool_step = msg
                 content = (
                     _extract_text_content(msg.content)
                     if hasattr(msg, "content")
                     else ""
                 )
+                thinking = _extract_thinking_content(msg)
+                # Yield standalone thinking message for tool-call chunks
+                if has_tools and thinking:
+                    thinking_message_create = ChatMessageCreate(
+                        id=str(XID()),
+                        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.THINKING,
+                        model=agent.model,
+                        thread_type=user_message.author_type,
+                        reply_to=user_message.id,
+                        message=thinking,
+                    )
+                    thinking_message = await thinking_message_create.save()
+                    yielded_any = True
+                    yield thinking_message
                 if content and not has_tools:
                     chat_message_create = ChatMessageCreate(
                         id=str(XID()),
@@ -698,6 +765,7 @@ async def stream_agent_raw(
                         thread_type=user_message.author_type,
                         reply_to=user_message.id,
                         message=content,
+                        thinking=thinking,
                         input_tokens=(
                             msg.usage_metadata.get("input_tokens", 0)
                             if hasattr(msg, "usage_metadata") and msg.usage_metadata
@@ -748,6 +816,7 @@ async def stream_agent_raw(
                         yielded_any = True
                         yield chat_message
             elif "tools" in chunk and "messages" in chunk["tools"]:
+                in_tools_phase = False
                 if not cached_tool_step:
                     logger.error(
                         "unexpected tools message: " + str(chunk["tools"]),
@@ -884,8 +953,10 @@ async def stream_agent_raw(
                             if isinstance(message, BaseMessage)
                         ]
                         content = ""
+                        thinking = None
                         if ai_messages:
                             content = _extract_text_content(ai_messages[-1].content)
+                            thinking = _extract_thinking_content(ai_messages[-1])
                         post_model_message_create = ChatMessageCreate(
                             id=str(XID()),
                             agent_id=user_message.agent_id,
@@ -897,6 +968,7 @@ async def stream_agent_raw(
                             thread_type=user_message.author_type,
                             reply_to=user_message.id,
                             message=content,
+                            thinking=thinking,
                             input_tokens=0,
                             output_tokens=0,
                             time_cost=this_time - last,
@@ -921,6 +993,30 @@ async def stream_agent_raw(
                         error_message = await error_message_create.save()
                         yield error_message
                         return
+    except asyncio.CancelledError:
+        logger.info(
+            f"Agent execution cancelled for {user_message.agent_id}",
+            extra={"thread_id": thread_id},
+        )
+        if in_tools_phase:
+            # Cancelled during tool execution — checkpoint has tool_calls without results.
+            # Clear to prevent re-execution of tools on next message.
+            await clear_thread_memory(user_message.agent_id, user_message.chat_id)
+        # Save cancellation message directly (stream is already dead, can't yield)
+        cancel_message_create = ChatMessageCreate(
+            id=str(XID()),
+            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.SYSTEM,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
+            message="User cancelled the conversation",
+            time_cost=time.perf_counter() - start,
+        )
+        await cancel_message_create.save()
+        return
     except (httpx.TimeoutException, httpcore.ReadTimeout, asyncio.TimeoutError):
         logger.error(
             f"Agent request timed out for {user_message.agent_id}",

{intentkit-0.12.2 → intentkit-0.12.3}/intentkit/core/middleware.py

@@ -175,7 +175,7 @@ class ToolBindingMiddleware(AgentMiddleware[AgentState, AgentContext]):
                 elif model_info.provider == LLMProvider.OPENROUTER:
                     llm_params["plugins"] = [{"id": "web"}]
                 elif model_info.provider == LLMProvider.GOOGLE:
-                    tools.append({"google_search": {}})
+                    tools.extend([{"google_search": {}}, {"url_context": {}}])
             else:
                 logger.debug(
                     "Search requested but model does not support native search"

{intentkit-0.12.2 → intentkit-0.12.3}/intentkit/core/system_skills/__init__.py

@@ -4,6 +4,10 @@ These skills wrap core functionality and are available to all agents
 without additional configuration.
 """
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from intentkit.core.system_skills.base import SystemSkill
 from intentkit.core.system_skills.call_agent import CallAgentSkill
 from intentkit.core.system_skills.create_activity import CreateActivitySkill
@@ -14,6 +18,9 @@ from intentkit.core.system_skills.recent_activities import RecentActivitiesSkill
 from intentkit.core.system_skills.recent_posts import RecentPostsSkill
 from intentkit.core.system_skills.update_memory import UpdateMemorySkill
 
+if TYPE_CHECKING:
+    from intentkit.models.agent import Agent
+
 __all__ = [
     "SystemSkill",
     "CallAgentSkill",
@@ -37,35 +44,37 @@ _read_webpage = ReadWebpageSkill()
 _update_memory = UpdateMemorySkill()
 
 
-def get_system_skills(
-    enable_activity: bool = True,
-    enable_post: bool = True,
-    enable_long_term_memory: bool = False,
-    enable_sub_agents: bool = False,
-    search_internet: bool = True,
-) -> list[SystemSkill]:
-    """Get system skills instances filtered by flags.
+def get_system_skills(agent: Agent) -> list[SystemSkill]:
+    """Get system skills instances based on agent configuration.
 
     Args:
-        enable_activity: Whether to include activity skills. Defaults to True.
-        enable_post: Whether to include post skills. Defaults to True.
-        enable_long_term_memory: Whether to include memory skill. Defaults to False.
-        enable_sub_agents: Whether to include call_agent skill. Defaults to False.
-        search_internet: Whether to include read_webpage skill. Defaults to True.
+        agent: Agent configuration object. The following fields are used:
+            - enable_activity: Whether to include activity skills (default True).
+            - enable_post: Whether to include post skills (default True).
+            - enable_long_term_memory: Whether to include memory skill.
+            - sub_agents: Whether to include call_agent skill.
+            - search_internet: Whether to include read_webpage skill.
     """
     skills: list[SystemSkill] = []
-    if enable_sub_agents:
+    if agent.sub_agents:
         skills.append(_call_agent)
+
+    enable_activity = (
+        agent.enable_activity if agent.enable_activity is not None else True
+    )
     if enable_activity:
         skills.append(_create_activity)
         skills.append(_recent_activities)
+
+    enable_post = agent.enable_post if agent.enable_post is not None else True
     if enable_post:
         skills.append(_create_post)
         skills.append(_get_post)
         skills.append(_recent_posts)
-    if enable_long_term_memory:
+
+    if agent.enable_long_term_memory:
         skills.append(_update_memory)
-    if search_internet:
+    if agent.search_internet:
         from intentkit.config.config import config
 
         if config.cloudflare_account_id and config.cloudflare_api_token:

intentkit-0.12.3/intentkit/core/task_registry.py

@@ -0,0 +1,33 @@
+"""Task registry for tracking running streaming tasks.
+
+Simple module-level registry that maps (agent_id, chat_id) to asyncio.Task[None],
+enabling cancellation of in-progress streaming responses.
+"""
+
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Process-level registry: {(agent_id, chat_id): asyncio.Task[None]}
+_running_tasks: dict[tuple[str, str], asyncio.Task[None]] = {}
+
+
+def register_task(agent_id: str, chat_id: str, task: asyncio.Task[None]) -> None:
+    """Register a running streaming task."""
+    _running_tasks[(agent_id, chat_id)] = task
+
+
+def unregister_task(agent_id: str, chat_id: str) -> None:
+    """Unregister a streaming task."""
+    _running_tasks.pop((agent_id, chat_id), None)
+
+
+def cancel_task(agent_id: str, chat_id: str) -> bool:
+    """Cancel a running streaming task. Returns True if a task was found and cancelled."""
+    task = _running_tasks.get((agent_id, chat_id))
+    if task is None or task.done():
+        return False
+    task.cancel()
+    logger.info(f"Cancelled task for agent {agent_id}, chat {chat_id}")
+    return True

{intentkit-0.12.2 → intentkit-0.12.3}/intentkit/models/chat.py

@@ -45,6 +45,7 @@ class AuthorType(str, Enum):
     # output messages
     AGENT = "agent"
     SKILL = "skill"
+    THINKING = "thinking"
     SYSTEM = "system"
 
     # input messages
@@ -226,6 +227,7 @@ class ChatMessageTable(Base):
         nullable=True,
     )
     cold_start_cost: Mapped[float] = mapped_column(Float, default=0)
+    thinking: Mapped[str | None] = mapped_column(String, nullable=True)
     app_id: Mapped[str | None] = mapped_column(String, nullable=True)
     error_type: Mapped[SystemMessageType | None] = mapped_column(
         String,
@@ -307,6 +309,10 @@ class ChatMessageCreate(BaseModel):
         float,
         Field(0.0, description="Cost for the cold start of the message in seconds"),
     ] = 0.0
+    thinking: Annotated[
+        str | None,
+        Field(None, description="LLM thinking/reasoning content"),
+    ] = None
     app_id: Annotated[
         str | None,
         Field(None, description="Optional application identifier"),
@@ -431,6 +437,10 @@ class ChatMessage(ChatMessageCreate):
             resp += (
                 f"\n------------------- agent cost: {self.time_cost:.3f} seconds\n\n"
             )
+        elif self.author_type == AuthorType.THINKING:
+            resp += f"[ Thinking: ] ({self.created_at.strftime('%Y-%m-%d %H:%M:%S')} UTC)\n\n"
+            resp += f" {self.message}\n"
+            resp += "\n------------------- thinking\n\n"
         elif self.author_type == AuthorType.SYSTEM:
             resp += (
                 f"[ System: ] ({self.created_at.strftime('%Y-%m-%d %H:%M:%S')} UTC)\n\n"

{intentkit-0.12.2 → intentkit-0.12.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.12.2"
+version = "0.12.3"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [
     { name = "Ruihua", email = "ruihua@crestal.network" },