intentkit 1.2.1__tar.gz → 1.2.2__tar.gz

{intentkit-1.2.1 → intentkit-1.2.2}/PKG-INFO

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

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

{intentkit-1.2.1 → intentkit-1.2.2}/intentkit/core/lead/engine.py

@@ -70,8 +70,8 @@ async def _build_lead_agent(team_id: str) -> Agent:
     prompt = (
         "### Sub-Agents\n\n"
         "Use `lead_call_agent` to delegate:\n\n"
-        "- `agent-manager`: Agent CRUD.\n"
-        "- `task-manager`: Autonomous task scheduling and management.\n"
+        "- `agent-manager`: Manage team agents — create, configure, update, "
+        "and schedule autonomous (cron) tasks on them.\n"
         "- `self-updater`: Update your own name, avatar, personality, or memory.\n"
         "- `content-manager`: Read team activities and posts.\n"
         "- `user-manager`: Update the current user's profile (name, timezone, language).\n\n"

{intentkit-1.2.1 → intentkit-1.2.2}/intentkit/core/lead/skills/call_agent.py

@@ -43,7 +43,7 @@ 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.)
+    1. Check in-memory sub-agent registry (agent-manager, self-updater, etc.)
     2. Fall back to database agent lookup (scoped to team)
     """
 

{intentkit-1.2.1 → intentkit-1.2.2}/intentkit/core/lead/sub_agents/__init__.py

@@ -20,7 +20,6 @@ logger = logging.getLogger(__name__)
 
 # Sub-agent slug constants
 SLUG_AGENT_MANAGER = "agent-manager"
-SLUG_TASK_MANAGER = "task-manager"
 SLUG_SELF_UPDATER = "self-updater"
 SLUG_CONTENT_MANAGER = "content-manager"
 SLUG_USER_MANAGER = "user-manager"
@@ -109,10 +108,6 @@ from intentkit.core.lead.sub_agents.self_updater import (  # noqa: E402
     build_self_updater,
     get_self_updater_skills,
 )
-from intentkit.core.lead.sub_agents.task_manager import (  # noqa: E402
-    build_task_manager,
-    get_task_manager_skills,
-)
 from intentkit.core.lead.sub_agents.user_manager import (  # noqa: E402
     build_user_manager,
     get_user_manager_skills,
@@ -122,20 +117,13 @@ SUB_AGENT_REGISTRY: dict[str, SubAgentDefinition] = {
     SLUG_AGENT_MANAGER: SubAgentDefinition(
         slug=SLUG_AGENT_MANAGER,
         description=(
-            "Manages team agents: create, update, configure, list agents. "
-            "Also provides LLM model info and available skills for agent configuration."
+            "Manages team agents end-to-end: create, update, configure, list "
+            "agents, and schedule autonomous tasks on them. Also exposes LLM "
+            "model info and available skills for agent configuration."
         ),
         build_fn=build_agent_manager,
         skills_fn=get_agent_manager_skills,
     ),
-    SLUG_TASK_MANAGER: SubAgentDefinition(
-        slug=SLUG_TASK_MANAGER,
-        description=(
-            "Manages autonomous tasks: list, add, edit, delete scheduled tasks for agents."
-        ),
-        build_fn=build_task_manager,
-        skills_fn=get_task_manager_skills,
-    ),
     SLUG_SELF_UPDATER: SubAgentDefinition(
         slug=SLUG_SELF_UPDATER,
         description=(

{intentkit-1.2.1 → intentkit-1.2.2}/intentkit/core/lead/sub_agents/agent_manager.py

@@ -1,4 +1,4 @@
-"""Agent Manager sub-agent definition."""
+"""Agent Manager sub-agent: agent CRUD plus autonomous tasks scheduled on those agents."""
 
 from __future__ import annotations
 
@@ -7,9 +7,21 @@ from datetime import datetime, timezone
 
 from langchain_core.tools import BaseTool
 
+from intentkit.core.lead.skills.add_autonomous_task import (
+    lead_add_autonomous_task_skill,
+)
 from intentkit.core.lead.skills.create_team_agent import create_team_agent_skill
+from intentkit.core.lead.skills.delete_autonomous_task import (
+    lead_delete_autonomous_task_skill,
+)
+from intentkit.core.lead.skills.edit_autonomous_task import (
+    lead_edit_autonomous_task_skill,
+)
 from intentkit.core.lead.skills.get_team_agent import get_team_agent_skill
 from intentkit.core.lead.skills.get_team_info import get_team_info_skill
+from intentkit.core.lead.skills.list_autonomous_tasks import (
+    lead_list_autonomous_tasks_skill,
+)
 from intentkit.core.lead.skills.list_skills import lead_list_available_skills_skill
 from intentkit.core.lead.skills.list_team_agents import list_team_agents_skill
 from intentkit.core.lead.skills.llm import lead_get_available_llms_skill
@@ -28,6 +40,10 @@ def get_agent_manager_skills() -> Sequence[BaseTool]:
         update_team_agent_skill,
         lead_get_available_llms_skill,
         lead_list_available_skills_skill,
+        lead_list_autonomous_tasks_skill,
+        lead_add_autonomous_task_skill,
+        lead_edit_autonomous_task_skill,
+        lead_delete_autonomous_task_skill,
     ]
 
 
@@ -76,6 +92,37 @@ def build_agent_manager(team_id: str) -> Agent:
         "- Access levels: `public` (all users), `private` (owner only)\n"
         "- Only include skills you want to enable — omitted skills stay disabled\n"
         "- The backend will reject unknown categories or skill names with an error\n\n"
+        "### Internet Search\n\n"
+        "To give an agent web search ability, set the agent field "
+        "`search_internet` to `true`. That switch enables the LLM provider's "
+        "native web search and is the correct way to add general-purpose "
+        "search. Do NOT add categories like `tavily`, `firecrawl`, "
+        "`web_scraper`, etc. just to grant search — those are backups for "
+        "specialised scraping/extraction needs and only belong in `skills` "
+        "when the agent really needs them.\n\n"
+        "### Autonomous Tasks\n\n"
+        "Tasks belong to an agent and run on a cron schedule. Use these tools:\n"
+        "- `lead_list_autonomous_tasks` — list tasks on an agent (call before "
+        "edit/delete to discover task IDs).\n"
+        "- `lead_add_autonomous_task` — schedule a new task.\n"
+        "- `lead_edit_autonomous_task` — update fields on an existing task.\n"
+        "- `lead_delete_autonomous_task` — remove a task.\n\n"
+        "Workflow:\n"
+        "1. If the user did not name an agent, call `lead_list_team_agents`.\n"
+        "2. Call `lead_list_autonomous_tasks` to see existing tasks before "
+        "adding/editing/deleting.\n"
+        "3. Apply the change.\n\n"
+        "Cron expressions (5 fields: min hour day month weekday):\n"
+        "- `*/5 * * * *` — every 5 min\n"
+        "- `0 */2 * * *` — every 2 hours\n"
+        "- `0 9 * * *` — daily 9:00 UTC\n"
+        "- `0 9 * * 1-5` — weekdays 9:00 UTC\n\n"
+        "Conditional tasks: for condition-based work, schedule a polling "
+        "task (e.g. every 5 min). Unless the user wants it to run forever, "
+        "tell the task to delete itself once the condition is met.\n\n"
+        "Tips:\n"
+        "- Set `has_memory=True` only when the task needs context between runs.\n"
+        "- Prefer disabling (`enabled=False`) over deleting for temporary pauses.\n\n"
         "### Agent Fields Reference\n\n"
         "- `name`: Display name (max 50 chars)\n"
         "- `purpose`, `personality`, `principles`: Agent character\n"
@@ -99,9 +146,12 @@ def build_agent_manager(team_id: str) -> Agent:
         "owner": "system",
         "team_id": team_id,
         "name": "Agent Manager",
-        "purpose": "Create, configure, and update team agents.",
+        "purpose": (
+            "Create, configure, and update team agents, including the "
+            "autonomous tasks scheduled on those agents."
+        ),
         "principles": (
-            "1. Speak to users in their language, but use English in agent configuration.\n"
+            "1. Speak to users in their language, but use English in agent and task configuration.\n"
             "2. All changes are directly deployed (no draft flow).\n"
             "3. Update is override — provide complete field values, not just changes."
         ),

{intentkit-1.2.1 → intentkit-1.2.2}/intentkit/core/manager/engine.py

@@ -102,6 +102,12 @@ def _build_manager_agent(agent_id: str, user_id: str) -> Agent:
         ```
         The `enabled` flag is at the category level, and `states` refers to specific skills.
         For content involving sensitive material, select `private`. For content suitable for all users, select `public`.
+
+        Internet search: to give an agent web search, set the agent field `search_internet` to `true`.
+        That switch enables the LLM provider's native web search and is the right tool for general-purpose
+        searching. Do NOT add categories like `tavily`, `firecrawl`, `web_scraper`, etc. just to give the
+        agent search ability — those categories are backups for specialised scraping/extraction needs and
+        only belong in the skills config when the agent really requires them.
         """
         "\n\n### Public Information\n\n"
         "Only agents that have already been deployed at least once can have their public"

{intentkit-1.2.1 → intentkit-1.2.2}/intentkit/core/manager/service.py

@@ -13,6 +13,12 @@ from fastapi import status
 
 from intentkit.core.agent import get_agent
 from intentkit.models.agent import AgentPublicInfo, AgentUserInput
+from intentkit.skills.availability import (
+    filter_unavailable_states,
+    import_skill_category,
+    is_individual_skill_available,
+    is_skill_category_available,
+)
 from intentkit.utils.error import IntentKitAPIError
 
 logger = logging.getLogger(__name__)
@@ -50,8 +56,18 @@ def agent_draft_json_schema() -> dict[str, object]:
                 if not schema_path.is_file():
                     continue
 
+                category = entry.name
+
+                module = import_skill_category(category)
+                if module is None or not is_skill_category_available(module):
+                    logger.info(
+                        "Skipped skill category '%s' for manager schema: not available",
+                        category,
+                    )
+                    continue
+
                 try:
-                    skills_properties[entry.name] = _load_skill_schema(schema_path)
+                    skill_schema = _load_skill_schema(schema_path)
                 except (
                     OSError,
                     ValueError,
@@ -59,9 +75,19 @@ def agent_draft_json_schema() -> dict[str, object]:
                     jsonref.JsonRefError,
                 ) as exc:
                     logger.warning(
-                        "Failed to load schema for skill '%s': %s", entry.name, exc
+                        "Failed to load schema for skill '%s': %s", category, exc
                     )
                     continue
+
+                schema_props = skill_schema.get("properties")
+                if isinstance(schema_props, dict):
+                    states = schema_props.get("states")
+                    if isinstance(states, dict):
+                        schema_props["states"] = filter_unavailable_states(
+                            module, category, states
+                        )
+
+                skills_properties[category] = skill_schema
     except (AttributeError, ModuleNotFoundError, ImportError):
         logger.warning("intentkit skills package not found when building schema")
         return schema
@@ -88,28 +114,38 @@ def get_skills_hierarchical_text() -> str:
                 if not schema_path.is_file():
                     continue
 
+                category = entry.name
+
+                module = import_skill_category(category)
+                if module is None or not is_skill_category_available(module):
+                    logger.info(
+                        "Skipped skill category '%s' for hierarchical text: "
+                        "not available",
+                        category,
+                    )
+                    continue
+
                 try:
                     skill_schema = _load_skill_schema(schema_path)
-                    skill_name = entry.name
                     skill_title = skill_schema.get(
-                        "title", skill_name.replace("_", " ").title()
+                        "title", category.replace("_", " ").title()
                     )
                     skill_description = skill_schema.get(
                         "description", "No description available"
                     )
                     skill_tags = cast(list[str], skill_schema.get("x-tags", ["Other"]))
 
-                    # Use the first tag as the primary category
+                    # Use the first tag as the primary group
                     primary_category = skill_tags[0] if skill_tags else "Other"
 
-                    if primary_category not in categories:
-                        categories[primary_category] = []
-
-                    # Extract individual skills from states.properties
                     individual_skills: list[dict[str, str]] = []
                     states_props = _get_states_properties(skill_schema)
                     if states_props:
                         for ind_name, ind_def in states_props.items():
+                            if not is_individual_skill_available(
+                                module, category, ind_name
+                            ):
+                                continue
                             ind_desc = (
                                 ind_def.get("description", "No description available")
                                 if isinstance(ind_def, dict)
@@ -119,9 +155,17 @@ def get_skills_hierarchical_text() -> str:
                                 {"name": ind_name, "description": ind_desc}
                             )
 
+                    # Drop the category entirely if every skill was filtered;
+                    # surfacing an empty group would just be noise to the LLM.
+                    if states_props and not individual_skills:
+                        continue
+
+                    if primary_category not in categories:
+                        categories[primary_category] = []
+
                     categories[primary_category].append(
                         {
-                            "name": skill_name,
+                            "name": category,
                             "title": skill_title,
                             "description": skill_description,
                             "individual_skills": individual_skills,
@@ -135,7 +179,7 @@ def get_skills_hierarchical_text() -> str:
                     jsonref.JsonRefError,
                 ) as exc:
                     logger.warning(
-                        "Failed to load schema for skill '%s': %s", entry.name, exc
+                        "Failed to load schema for skill '%s': %s", category, exc
                     )
                     continue
     except (AttributeError, ModuleNotFoundError, ImportError):

intentkit-1.2.2/intentkit/skills/availability.py

@@ -0,0 +1,118 @@
+"""Helpers for inspecting which skills are usable in the current deployment.
+
+A skill category exposes a module-level ``available()`` callable that checks
+its system config (API keys, env vars, etc.). Individual skills inside a
+category may also expose ``available()`` on the instance for finer-grained
+gating (e.g. wallet/scope checks). These helpers wrap both layers so callers
+that build user-facing skill listings (``app/common/schema.py``,
+``intentkit/core/manager/service.py``) can drop everything that wouldn't
+actually run.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from types import ModuleType
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+def import_skill_category(category: str) -> ModuleType | None:
+    """Import a skill category module, returning None on failure."""
+    try:
+        return importlib.import_module(f"intentkit.skills.{category}")
+    except Exception as exc:
+        logger.warning("Could not import skill category '%s': %s", category, exc)
+        return None
+
+
+def is_skill_category_available(module: ModuleType) -> bool:
+    """Whether the category module reports itself available.
+
+    Missing ``available()`` defaults to True; a raising ``available()``
+    defaults to False so a misconfigured skill never blocks the listing.
+    """
+    available_fn = getattr(module, "available", None)
+    if available_fn is None:
+        return True
+    try:
+        return bool(available_fn())
+    except Exception as exc:
+        logger.debug(
+            "available() raised for category module %r: %s", module.__name__, exc
+        )
+        return False
+
+
+def find_skill_getter(module: ModuleType, category: str) -> Callable[..., Any] | None:
+    """Locate the ``get_<name>_skill`` accessor for a category module.
+
+    Convention is ``get_{category}_skill``; falls back to any ``get_*_skill``
+    attribute (e.g. ``moralis`` exposes ``get_wallet_skill``).
+    """
+    getter = getattr(module, f"get_{category}_skill", None)
+    if getter is not None:
+        return getter
+    for attr_name in dir(module):
+        if attr_name.startswith("get_") and attr_name.endswith("_skill"):
+            return getattr(module, attr_name)
+    return None
+
+
+def is_individual_skill_available(
+    module: ModuleType, category: str, skill_name: str
+) -> bool:
+    """Whether a specific skill within a category reports itself available.
+
+    Defaults to True when the module has no getter, the getter raises, the
+    skill instance is None, or the skill exposes no ``available()``.
+    """
+    getter = find_skill_getter(module, category)
+    if getter is None:
+        return True
+    try:
+        skill = getter(skill_name)
+    except Exception as exc:
+        logger.debug("Skill getter raised for '%s/%s': %s", category, skill_name, exc)
+        return True
+    if skill is None:
+        return True
+    available_fn = getattr(skill, "available", None)
+    if available_fn is None:
+        return True
+    try:
+        return bool(available_fn())
+    except Exception as exc:
+        logger.debug(
+            "available() raised for skill '%s/%s': %s", category, skill_name, exc
+        )
+        return False
+
+
+def filter_unavailable_states(
+    module: ModuleType, category: str, states_schema: dict[str, Any]
+) -> dict[str, Any]:
+    """Drop unavailable individual skills from a JSON-schema ``states`` block.
+
+    Returns a new dict with ``properties`` (and ``required``, if present)
+    pruned. The input is not mutated.
+    """
+    properties = states_schema.get("properties")
+    if not isinstance(properties, dict):
+        return states_schema
+
+    filtered_properties: dict[str, Any] = {}
+    for skill_name, skill_schema in properties.items():
+        if not is_individual_skill_available(module, category, skill_name):
+            logger.info(
+                "Filtered out skill '%s/%s': not available", category, skill_name
+            )
+            continue
+        filtered_properties[skill_name] = skill_schema
+
+    result = {**states_schema, "properties": filtered_properties}
+    if "required" in result and isinstance(result["required"], list):
+        result["required"] = [r for r in result["required"] if r in filtered_properties]
+    return result

{intentkit-1.2.1 → intentkit-1.2.2}/pyproject.toml

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

intentkit-1.2.1/intentkit/core/lead/sub_agents/task_manager.py

@@ -1,94 +0,0 @@
-"""Task Manager sub-agent definition."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from datetime import datetime, timezone
-
-from langchain_core.tools import BaseTool
-
-from intentkit.core.lead.skills.add_autonomous_task import (
-    lead_add_autonomous_task_skill,
-)
-from intentkit.core.lead.skills.delete_autonomous_task import (
-    lead_delete_autonomous_task_skill,
-)
-from intentkit.core.lead.skills.edit_autonomous_task import (
-    lead_edit_autonomous_task_skill,
-)
-from intentkit.core.lead.skills.list_autonomous_tasks import (
-    lead_list_autonomous_tasks_skill,
-)
-from intentkit.core.lead.skills.list_team_agents import list_team_agents_skill
-from intentkit.models.agent import Agent
-from intentkit.models.llm_picker import pick_default_model
-
-
-def get_task_manager_skills() -> Sequence[BaseTool]:
-    """Return skills for the task manager sub-agent."""
-    return [
-        list_team_agents_skill,
-        lead_list_autonomous_tasks_skill,
-        lead_add_autonomous_task_skill,
-        lead_edit_autonomous_task_skill,
-        lead_delete_autonomous_task_skill,
-    ]
-
-
-def build_task_manager(team_id: str) -> Agent:
-    """Build an in-memory Task Manager sub-agent."""
-    now = datetime.now(timezone.utc)
-
-    prompt = (
-        "### Workflow\n\n"
-        "1. If agent unspecified, call `lead_list_team_agents`.\n"
-        "2. `lead_list_autonomous_tasks` to see existing tasks.\n"
-        "3. Add, edit, or delete as needed.\n\n"
-        "### Cron Expressions\n\n"
-        "5 fields: min hour day month weekday\n"
-        "- `*/5 * * * *` — every 5 min\n"
-        "- `0 */2 * * *` — every 2 hours\n"
-        "- `0 9 * * *` — daily 9:00 UTC\n"
-        "- `0 9 * * 1-5` — weekdays 9:00 UTC\n\n"
-        "### Conditional Tasks\n\n"
-        "For condition-based tasks, create a polling task (e.g., every 5 min). "
-        "Unless user says continuous, add self-deletion after success in the prompt.\n\n"
-        "### Tips\n\n"
-        "- `has_memory=True` only when needing context between runs\n"
-        "- Disable (`enabled=False`) rather than delete for temporary pauses\n"
-    )
-
-    agent_data = {
-        "id": f"team-{team_id}-task-manager",
-        "owner": "system",
-        "team_id": team_id,
-        "name": "Task Manager",
-        "purpose": "Manage autonomous scheduled tasks for team agents.",
-        "principles": (
-            "1. Speak to users in their language, but use English in task configuration.\n"
-            "2. Use clear, descriptive task names."
-        ),
-        "model": pick_default_model(),
-        "prompt": prompt,
-        "temperature": 0.2,
-        "search_internet": False,
-        "super_mode": False,
-        "enable_todo": False,
-        "enable_activity": False,
-        "enable_post": False,
-        "enable_long_term_memory": False,
-        "sub_agents": None,
-        "skills": {
-            "ui": {
-                "enabled": True,
-                "states": {
-                    "ui_show_card": "private",
-                    "ui_ask_user": "private",
-                },
-            },
-        },
-        "created_at": now,
-        "updated_at": now,
-    }
-
-    return Agent.model_validate(agent_data)