intentkit 0.17.26__tar.gz → 0.17.28__tar.gz

{intentkit-0.17.26 → intentkit-0.17.28}/PKG-INFO

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

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

{intentkit-0.17.26 → intentkit-0.17.28}/intentkit/core/lead/cache.py

@@ -23,8 +23,9 @@ lead_cached_at: dict[str, datetime] = {}
 def invalidate_lead_cache(team_id: str) -> None:
     """Remove cached lead agent and executor for a team.
 
-    Call this when the team's agent list changes (create, archive, reactivate)
-    so the lead agent is rebuilt with an up-to-date sub_agents list.
+    Call this when the team's agent list changes (create, archive, reactivate).
+    Sub-agent caches are NOT invalidated here because sub-agents are static
+    definitions that don't depend on the team's agent list.
     """
     _ = lead_cached_at.pop(team_id, None)
     _ = lead_executors.pop(team_id, None)
@@ -46,3 +47,7 @@ def cleanup_cache(now: datetime) -> None:
             _ = lead_executors.pop(cache_key, None)
             _ = lead_agents.pop(cache_key, None)
             logger.debug("Removed expired lead executor for %s", cache_key)
+
+    from intentkit.core.lead.sub_agents import cleanup_sub_agent_caches
+
+    cleanup_sub_agent_caches(expired_before)

intentkit-0.17.28/intentkit/core/lead/constants.py

@@ -0,0 +1,7 @@
+"""Shared constants for the lead agent system."""
+
+# Defaults for the lead agent — used by engine and get_self_info skill.
+LEAD_DEFAULT_NAME = "Team Lead"
+LEAD_DEFAULT_PERSONALITY = (
+    "Helpful team assistant. Let sub-agents handle technical details."
+)

intentkit-0.17.28/intentkit/core/lead/engine.py

@@ -0,0 +1,179 @@
+"""Streaming utilities for the on-demand lead agent."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from collections.abc import AsyncGenerator
+from datetime import datetime, timezone
+from typing import Any
+
+from langgraph.graph.state import CompiledStateGraph
+
+from intentkit.abstracts.graph import AgentContext, AgentState
+from intentkit.core.engine import stream_agent_raw
+from intentkit.core.executor import build_executor
+from intentkit.core.lead.cache import (
+    cleanup_cache,
+    lead_agents,
+    lead_cached_at,
+    lead_executors,
+)
+from intentkit.core.lead.constants import LEAD_DEFAULT_NAME, LEAD_DEFAULT_PERSONALITY
+from intentkit.core.lead.service import verify_team_membership
+from intentkit.core.lead.skills import (
+    get_team_info_skill,
+    list_team_agents_skill,
+)
+from intentkit.core.lead.skills.call_agent import lead_call_agent_skill
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData
+from intentkit.models.chat import ChatMessage, ChatMessageCreate
+from intentkit.models.llm_picker import pick_default_model
+from intentkit.models.team import Team
+from intentkit.utils.error import IntentKitAPIError
+
+logger = logging.getLogger(__name__)
+
+
+async def get_lead_agent(team_id: str) -> Agent:
+    """Get the lead agent for a team, using cache if available."""
+    lead_agent = lead_agents.get(team_id)
+    if not lead_agent:
+        lead_agent = await _build_lead_agent(team_id)
+    return lead_agent
+
+
+async def stream_lead(
+    team_id: str, user_id: str, message: ChatMessageCreate
+) -> AsyncGenerator[ChatMessage, None]:
+    """Stream chat messages for the lead agent of a team."""
+
+    await verify_team_membership(team_id, user_id)
+
+    executor, lead_agent, cold_start_cost = await _get_lead_executor(team_id)
+
+    if not message.agent_id:
+        message.agent_id = lead_agent.id
+    if not message.team_id:
+        message.team_id = team_id
+    message.cold_start_cost = cold_start_cost
+
+    async for chat_message in stream_agent_raw(message, lead_agent, executor):
+        yield chat_message
+
+
+async def _build_lead_agent(team_id: str) -> Agent:
+    now = datetime.now(timezone.utc)
+
+    prompt = (
+        "### Sub-Agents\n\n"
+        "Use `lead_call_agent` to delegate:\n\n"
+        "- `agent-manager`: Agent CRUD, LLM model info, skill listing.\n"
+        "- `task-manager`: Autonomous task scheduling and management.\n"
+        "- `self-updater`: Update your own name, avatar, personality, or memory.\n"
+        "- `content-manager`: Read team activities and posts.\n\n"
+        "### Workflow\n\n"
+        "- Agent operations (create, configure, update, model/skill queries) "
+        "→ `agent-manager`\n"
+        "- Task management (schedule, edit, delete) → `task-manager`\n"
+        "- Self-improvement (update your name, avatar, personality, memory) "
+        "→ `self-updater`\n"
+        "- Content review (activities, posts) → `content-manager`\n"
+        "- Quick team overview → answer directly via "
+        "`lead_get_team_info` or `lead_list_team_agents`\n"
+        "- Pass full user context when delegating, including agent IDs/names if provided.\n"
+    )
+
+    # Parallelize independent DB lookups
+    owner, lead_config = await asyncio.gather(
+        Team.get_owner(team_id),
+        Team.get_lead_agent_config(team_id),
+    )
+    if not owner:
+        raise IntentKitAPIError(
+            500, "TeamOwnerNotFound", f"Team '{team_id}' has no owner"
+        )
+    lead_config = lead_config or {}
+
+    agent_data = {
+        "id": "team-" + team_id,
+        "owner": owner,
+        "team_id": team_id,
+        "name": lead_config.get("name", LEAD_DEFAULT_NAME),
+        "purpose": "Coordinate sub-agents for team agent and task management.",
+        "personality": lead_config.get("personality", LEAD_DEFAULT_PERSONALITY),
+        "principles": "Speak to users in the language they ask their questions.",
+        "model": pick_default_model(),
+        "prompt": prompt,
+        "prompt_append": None,
+        "temperature": 0.2,
+        "frequency_penalty": 0.0,
+        "presence_penalty": 0.0,
+        "search_internet": True,
+        "super_mode": False,
+        "enable_todo": False,
+        "enable_activity": False,
+        "enable_post": False,
+        "enable_long_term_memory": True,
+        "sub_agents": None,
+        "skills": {
+            "ui": {
+                "enabled": True,
+                "states": {
+                    "ui_show_card": "private",
+                    "ui_ask_user": "private",
+                },
+            },
+        },
+        "created_at": now,
+        "updated_at": now,
+    }
+
+    agent = Agent.model_validate(agent_data)
+
+    # Apply persisted avatar override
+    if lead_config.get("avatar"):
+        agent.picture = lead_config["avatar"]
+
+    return agent
+
+
+async def _get_lead_executor(
+    team_id: str,
+) -> tuple[CompiledStateGraph[AgentState, AgentContext, Any, Any], Agent, float]:
+    now = datetime.now(timezone.utc)
+    cleanup_cache(now)
+
+    executor = lead_executors.get(team_id)
+    lead_agent = lead_agents.get(team_id)
+    cold_start_cost = 0.0
+
+    if not executor or not lead_agent:
+        start = time.perf_counter()
+
+        if not lead_agent:
+            lead_agent = await _build_lead_agent(team_id)
+            lead_agents[team_id] = lead_agent
+
+        if not executor:
+            custom_skills = [
+                lead_call_agent_skill,
+                get_team_info_skill,
+                list_team_agents_skill,
+            ]
+            executor = await build_executor(
+                lead_agent,
+                AgentData.model_construct(id=lead_agent.id),
+                custom_skills,
+            )
+            lead_executors[team_id] = executor
+
+        cold_start_cost = time.perf_counter() - start
+        lead_cached_at[team_id] = now
+        logger.info("Initialized lead executor for team %s", team_id)
+    else:
+        lead_cached_at[team_id] = now
+
+    return executor, lead_agent, cold_start_cost

{intentkit-0.17.26 → intentkit-0.17.28}/intentkit/core/lead/skills/__init__.py

@@ -4,6 +4,10 @@ from intentkit.core.lead.skills.add_autonomous_task import (
     LeadAddAutonomousTask,
     lead_add_autonomous_task_skill,
 )
+from intentkit.core.lead.skills.call_agent import (
+    LeadCallAgent,
+    lead_call_agent_skill,
+)
 from intentkit.core.lead.skills.create_team_agent import (
     CreateTeamAgent,
     create_team_agent_skill,
@@ -16,6 +20,14 @@ from intentkit.core.lead.skills.edit_autonomous_task import (
     LeadEditAutonomousTask,
     lead_edit_autonomous_task_skill,
 )
+from intentkit.core.lead.skills.get_post import (
+    LeadGetPost,
+    lead_get_post_skill,
+)
+from intentkit.core.lead.skills.get_self_info import (
+    LeadGetSelfInfo,
+    lead_get_self_info_skill,
+)
 from intentkit.core.lead.skills.get_team_agent import (
     GetTeamAgent,
     get_team_agent_skill,
@@ -28,6 +40,10 @@ from intentkit.core.lead.skills.list_autonomous_tasks import (
     LeadListAutonomousTasks,
     lead_list_autonomous_tasks_skill,
 )
+from intentkit.core.lead.skills.list_skills import (
+    LeadListAvailableSkills,
+    lead_list_available_skills_skill,
+)
 from intentkit.core.lead.skills.list_team_agents import (
     ListTeamAgents,
     list_team_agents_skill,
@@ -36,6 +52,22 @@ from intentkit.core.lead.skills.llm import (
     LeadGetAvailableLLMs,
     lead_get_available_llms_skill,
 )
+from intentkit.core.lead.skills.recent_team_activities import (
+    LeadRecentTeamActivities,
+    lead_recent_team_activities_skill,
+)
+from intentkit.core.lead.skills.recent_team_posts import (
+    LeadRecentTeamPosts,
+    lead_recent_team_posts_skill,
+)
+from intentkit.core.lead.skills.update_self import (
+    LeadUpdateSelf,
+    lead_update_self_skill,
+)
+from intentkit.core.lead.skills.update_self_memory import (
+    LeadUpdateSelfMemory,
+    lead_update_self_memory_skill,
+)
 from intentkit.core.lead.skills.update_team_agent import (
     UpdateTeamAgent,
     update_team_agent_skill,
@@ -50,14 +82,30 @@ __all__ = [
     "get_team_info_skill",
     "LeadAddAutonomousTask",
     "lead_add_autonomous_task_skill",
+    "LeadCallAgent",
+    "lead_call_agent_skill",
     "LeadDeleteAutonomousTask",
     "lead_delete_autonomous_task_skill",
     "LeadEditAutonomousTask",
     "lead_edit_autonomous_task_skill",
     "LeadGetAvailableLLMs",
     "lead_get_available_llms_skill",
+    "LeadGetPost",
+    "lead_get_post_skill",
+    "LeadGetSelfInfo",
+    "lead_get_self_info_skill",
     "LeadListAutonomousTasks",
     "lead_list_autonomous_tasks_skill",
+    "LeadListAvailableSkills",
+    "lead_list_available_skills_skill",
+    "LeadRecentTeamActivities",
+    "lead_recent_team_activities_skill",
+    "LeadRecentTeamPosts",
+    "lead_recent_team_posts_skill",
+    "LeadUpdateSelf",
+    "lead_update_self_skill",
+    "LeadUpdateSelfMemory",
+    "lead_update_self_memory_skill",
     "ListTeamAgents",
     "list_team_agents_skill",
     "UpdateTeamAgent",

{intentkit-0.17.26 → intentkit-0.17.28}/intentkit/core/lead/skills/add_autonomous_task.py

@@ -63,7 +63,7 @@ class LeadAddAutonomousTask(LeadSkill):
         **kwargs: Any,
     ) -> AddAutonomousTaskOutput:
         context = self.get_context()
-        await verify_agent_in_team(agent_id, context.agent_id)
+        await verify_agent_in_team(agent_id, context.team_id)
 
         task_request = AutonomousCreateRequest(
             name=name,

intentkit-0.17.28/intentkit/core/lead/skills/call_agent.py

@@ -0,0 +1,197 @@
+"""Team-aware call_agent skill for the lead agent."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Literal, override
+
+from epyxid import XID
+from langchain_core.tools import ArgsSchema
+from langchain_core.tools.base import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.graph import AgentContext
+from intentkit.core.lead.skills.base import LeadSkill
+from intentkit.core.system_skills.call_agent import CALL_AGENT_TIMEOUT, MAX_CALL_DEPTH
+from intentkit.models.chat import (
+    AuthorType,
+    ChatMessage,
+    ChatMessageAttachment,
+    ChatMessageCreate,
+)
+
+
+class LeadCallAgentInput(BaseModel):
+    """Input schema for calling a sub-agent."""
+
+    agent_id: str = Field(..., description="Target agent ID or slug")
+    message: str = Field(..., description="Message to send")
+
+
+class LeadCallAgent(LeadSkill):
+    """Team-aware call_agent that supports both in-memory sub-agents and DB agents.
+
+    Resolution order:
+    1. Check in-memory sub-agent registry (agent-manager, task-manager, etc.)
+    2. Fall back to database agent lookup (scoped to team)
+    """
+
+    name: str = "lead_call_agent"
+    description: str = "Delegate a task to a sub-agent by sending it a message and receiving its response."
+    args_schema: ArgsSchema | None = LeadCallAgentInput
+    response_format: Literal["content", "content_and_artifact"] = "content_and_artifact"
+
+    @override
+    async def _arun(
+        self,
+        agent_id: str,
+        message: str,
+    ) -> tuple[str, list[ChatMessageAttachment]]:
+        try:
+            context = self.get_context()
+
+            if context.call_depth >= MAX_CALL_DEPTH:
+                raise ToolException(
+                    f"Maximum call_agent recursion depth ({MAX_CALL_DEPTH}) exceeded. "
+                    "Cannot call another agent from this depth."
+                )
+
+            from intentkit.core.lead.sub_agents import (
+                SUB_AGENT_REGISTRY,
+            )
+
+            team_id = context.team_id
+            if not team_id:
+                raise ToolException("No team_id in context")
+
+            if agent_id in SUB_AGENT_REGISTRY:
+                return await self._call_sub_agent(context, agent_id, message, team_id)
+
+            return await self._call_db_agent(context, agent_id, message)
+
+        except TimeoutError as e:
+            self.logger.error(
+                "lead_call_agent timed out after %ss for '%s'",
+                CALL_AGENT_TIMEOUT,
+                agent_id,
+            )
+            raise ToolException(
+                f"Agent '{agent_id}' did not respond within "
+                f"{CALL_AGENT_TIMEOUT} seconds"
+            ) from e
+        except ToolException:
+            raise
+        except Exception as e:
+            self.logger.error("lead_call_agent failed: %s", e, exc_info=True)
+            raise ToolException(f"Call agent failed with error: {e}") from e
+
+    async def _call_sub_agent(
+        self,
+        context: AgentContext,
+        slug: str,
+        message: str,
+        team_id: str,
+    ) -> tuple[str, list[ChatMessageAttachment]]:
+        """Call an in-memory sub-agent via stream_agent_raw."""
+        from intentkit.core.engine import stream_agent_raw
+        from intentkit.core.lead.sub_agents import get_sub_agent_executor
+
+        executor, sub_agent = await get_sub_agent_executor(team_id, slug)
+
+        chat_message = self._build_chat_message(context, sub_agent.id, team_id, message)
+
+        all_attachments: list[ChatMessageAttachment] = []
+        last_message = None
+
+        async with asyncio.timeout(CALL_AGENT_TIMEOUT):
+            async for chat_msg in stream_agent_raw(chat_message, sub_agent, executor):
+                if chat_msg.attachments:
+                    all_attachments.extend(chat_msg.attachments)
+                last_message = chat_msg
+
+        return self._check_response(last_message, all_attachments, slug)
+
+    async def _call_db_agent(
+        self,
+        context: AgentContext,
+        agent_id: str,
+        message: str,
+    ) -> tuple[str, list[ChatMessageAttachment]]:
+        """Call a database agent, scoped to the same team."""
+        from intentkit.core.agent import get_agent_by_id_or_slug
+        from intentkit.core.engine import execute_agent
+
+        resolved_agent = await get_agent_by_id_or_slug(agent_id)
+        if not resolved_agent:
+            raise ToolException(f"Agent '{agent_id}' not found")
+
+        if resolved_agent.team_id != context.team_id:
+            raise ToolException(f"Agent '{agent_id}' does not belong to this team")
+
+        chat_message = self._build_chat_message(
+            context, resolved_agent.id, context.team_id, message
+        )
+
+        async with asyncio.timeout(CALL_AGENT_TIMEOUT):
+            results = await execute_agent(chat_message)
+
+        if not results:
+            raise ToolException(f"No response received from agent '{agent_id}'")
+
+        all_attachments: list[ChatMessageAttachment] = []
+        for msg in results:
+            if msg.attachments:
+                all_attachments.extend(msg.attachments)
+
+        return self._check_response(results[-1], all_attachments, agent_id)
+
+    @staticmethod
+    def _build_chat_message(
+        context: AgentContext,
+        target_agent_id: str,
+        team_id: str | None,
+        message: str,
+    ) -> ChatMessageCreate:
+        """Build a ChatMessageCreate for calling a sub-agent."""
+        return ChatMessageCreate(
+            id=str(XID()),
+            agent_id=target_agent_id,
+            chat_id=f"call-{context.agent_id}-{context.chat_id}",
+            user_id=context.user_id,
+            author_id=context.agent_id,
+            author_type=AuthorType.INTERNAL,
+            thread_type=context.entrypoint,
+            team_id=team_id,
+            message=message,
+            call_depth=context.call_depth + 1,
+        )
+
+    @staticmethod
+    def _check_response(
+        last_message: ChatMessage | None,
+        all_attachments: list[ChatMessageAttachment],
+        agent_id: str,
+    ) -> tuple[str, list[ChatMessageAttachment]]:
+        """Validate the last message and return response text + attachments."""
+        if not last_message:
+            raise ToolException(f"No response received from agent '{agent_id}'")
+
+        if last_message.author_type == AuthorType.AGENT:
+            return last_message.message, all_attachments
+
+        if last_message.author_type == AuthorType.SYSTEM:
+            error_info = ""
+            if last_message.error_type:
+                error_info = f" (error_type: {last_message.error_type})"
+            raise ToolException(
+                f"Agent '{agent_id}' returned a system error{error_info}: "
+                f"{last_message.message}"
+            )
+
+        raise ToolException(
+            f"Agent '{agent_id}' did not return an agent response. "
+            f"Last message type: {last_message.author_type}"
+        )
+
+
+lead_call_agent_skill = LeadCallAgent()

{intentkit-0.17.26 → intentkit-0.17.28}/intentkit/core/lead/skills/create_team_agent.py

@@ -149,7 +149,7 @@ class CreateTeamAgent(LeadSkill):
         # Invalidate lead cache so lead agent rebuilds sub-agents list
         from intentkit.core.lead.cache import invalidate_lead_cache
 
-        invalidate_lead_cache(context.agent_id)
+        invalidate_lead_cache(context.team_id)
 
         return CreateTeamAgentOutput(
             agent_id=created_agent.id,

{intentkit-0.17.26 → intentkit-0.17.28}/intentkit/core/lead/skills/delete_autonomous_task.py

@@ -48,7 +48,7 @@ class LeadDeleteAutonomousTask(LeadSkill):
         **kwargs: Any,
     ) -> DeleteAutonomousTaskOutput:
         context = self.get_context()
-        await verify_agent_in_team(agent_id, context.agent_id)
+        await verify_agent_in_team(agent_id, context.team_id)
         await delete_autonomous_task(agent_id, task_id)
         return DeleteAutonomousTaskOutput(
             success=True, message=f"Successfully deleted autonomous task {task_id}"

{intentkit-0.17.26 → intentkit-0.17.28}/intentkit/core/lead/skills/edit_autonomous_task.py

@@ -63,7 +63,7 @@ class LeadEditAutonomousTask(LeadSkill):
         **kwargs: Any,
     ) -> EditAutonomousTaskOutput:
         context = self.get_context()
-        await verify_agent_in_team(agent_id, context.agent_id)
+        await verify_agent_in_team(agent_id, context.team_id)
 
         task_update = AutonomousUpdateRequest(
             name=name,

intentkit-0.17.28/intentkit/core/lead/skills/get_post.py

@@ -0,0 +1,67 @@
+"""Skill to retrieve a single post's full content for the lead agent."""
+
+from __future__ import annotations
+
+from typing import Any, override
+
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel, Field
+
+from intentkit.core.lead.skills.base import LeadSkill
+
+
+class LeadGetPostInput(BaseModel):
+    """Input schema for getting a post by ID."""
+
+    post_id: str = Field(..., description="The ID of the post to retrieve")
+
+
+class LeadGetPost(LeadSkill):
+    """Skill for retrieving a single post's full content by ID.
+
+    This is a lead-specific wrapper that can read posts from any agent in the team.
+    """
+
+    name: str = "lead_get_post"
+    description: str = "Get the full content of a post by its ID."
+    args_schema: ArgsSchema | None = LeadGetPostInput
+
+    @override
+    async def _arun(self, post_id: str, **kwargs: Any) -> str:
+        from intentkit.core.agent_post import get_agent_post
+        from intentkit.core.lead.service import verify_agent_in_team
+
+        context = self.get_context()
+
+        post = await get_agent_post(post_id)
+
+        if post is None:
+            return f"Post with ID '{post_id}' not found."
+
+        # Verify the post's agent belongs to this team
+        if context.team_id:
+            try:
+                await verify_agent_in_team(post.agent_id, context.team_id)
+            except Exception:
+                return f"Post with ID '{post_id}' not found."
+
+        result_lines = [
+            f"Post (ID: {post.id})",
+            f"Agent: {post.agent_name}",
+            f"Title: {post.title}",
+            f"Created: {post.created_at.isoformat()}",
+        ]
+        if post.slug:
+            result_lines.append(f"Slug: {post.slug}")
+        if post.excerpt:
+            result_lines.append(f"Excerpt: {post.excerpt}")
+        if post.tags:
+            result_lines.append(f"Tags: {', '.join(post.tags)}")
+        if post.cover:
+            result_lines.append(f"Cover: {post.cover}")
+        result_lines.append(f"\n{post.markdown}")
+
+        return "\n".join(result_lines)
+
+
+lead_get_post_skill = LeadGetPost()

intentkit-0.17.28/intentkit/core/lead/skills/get_self_info.py

@@ -0,0 +1,60 @@
+"""Skill to get the lead agent's current configuration."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, override
+
+from langchain_core.tools import ArgsSchema
+from langchain_core.tools.base import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.core.lead.constants import LEAD_DEFAULT_NAME, LEAD_DEFAULT_PERSONALITY
+from intentkit.core.lead.skills.base import LeadSkill
+from intentkit.models.agent_data import AgentData
+from intentkit.models.team import Team
+from intentkit.skills.base import NoArgsSchema
+
+
+class GetSelfInfoOutput(BaseModel):
+    """Output model for lead_get_self_info skill."""
+
+    name: str = Field(description="Current lead agent name")
+    avatar: str | None = Field(description="Current lead agent avatar URL")
+    personality: str | None = Field(description="Current lead agent personality")
+    memory: str | None = Field(description="Current lead agent long-term memory")
+
+
+class LeadGetSelfInfo(LeadSkill):
+    """Skill to retrieve the lead agent's current configuration."""
+
+    name: str = "lead_get_self_info"
+    description: str = (
+        "Get the lead agent's current name, avatar, personality, and memory."
+    )
+    args_schema: ArgsSchema | None = NoArgsSchema
+
+    @override
+    async def _arun(self, **kwargs: Any) -> GetSelfInfoOutput:
+        context = self.get_context()
+        team_id = context.team_id
+        if not team_id:
+            raise ToolException("No team_id in context")
+        lead_agent_id = f"team-{team_id}"
+
+        # Parallelize independent DB lookups
+        raw_config, agent_data = await asyncio.gather(
+            Team.get_lead_agent_config(team_id),
+            AgentData.get(lead_agent_id),
+        )
+        lead_config = raw_config or {}
+
+        return GetSelfInfoOutput(
+            name=lead_config.get("name", LEAD_DEFAULT_NAME),
+            avatar=lead_config.get("avatar"),
+            personality=lead_config.get("personality", LEAD_DEFAULT_PERSONALITY),
+            memory=agent_data.long_term_memory,
+        )
+
+
+lead_get_self_info_skill = LeadGetSelfInfo()