intentkit 0.7.5.dev20__py3-none-any.whl → 0.7.5.dev22__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.7.5-dev20"
+__version__ = "0.7.5-dev22"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/config/config.py

@@ -92,6 +92,7 @@ class Config:
         self.eternal_api_key = self.load("ETERNAL_API_KEY")
         self.reigent_api_key = self.load("REIGENT_API_KEY")
         self.venice_api_key = self.load("VENICE_API_KEY")
+        self.gatewayz_api_key = self.load("GATEWAYZ_API_KEY")
         # LLM Config
         self.system_prompt = self.load("SYSTEM_PROMPT")
         self.intentkit_prompt = self.load("INTENTKIT_PROMPT")

intentkit/core/engine.py

@@ -422,8 +422,8 @@ async def stream_agent_raw(
             input_message = re.sub(r"\b@web\b", "", input_message).strip()
 
     # content to llm
-    content = [
-        {"type": "text", "text": input_message},
+    messages = [
+        HumanMessage(content=input_message),
     ]
     # if the model doesn't natively support image parsing, add the image URLs to the message
     if image_urls:
@@ -431,23 +431,22 @@ async def stream_agent_raw(
             agent.has_image_parser_skill(is_private=is_private)
             and not model.supports_image_input
         ):
-            input_message += f"\n\nImages:\n{'\n'.join(image_urls)}"
-            content = [
-                {"type": "text", "text": input_message},
+            image_urls_text = "\n".join(image_urls)
+            input_message += f"\n\nImages:\n{image_urls_text}"
+            messages = [
+                HumanMessage(content=input_message),
             ]
         else:
             # anyway, pass it directly to LLM
-            content.extend(
+            messages.extend(
                 [
-                    {"type": "image_url", "image_url": {"url": image_url}}
+                    HumanMessage(
+                        content={"type": "image_url", "image_url": {"url": image_url}}
+                    )
                     for image_url in image_urls
                 ]
             )
 
-    messages = [
-        HumanMessage(content=content),
-    ]
-
     # stream config
     thread_id = f"{user_message.agent_id}-{user_message.chat_id}"
     stream_config = {

intentkit/models/agent.py

@@ -1466,81 +1466,109 @@ class Agent(AgentCreate, AgentPublicInfo):
                 ):
                     model_property["default"] = new_enum[0]
 
-            # Process skills property using defaults merged with database overrides
+            # Process skills property using data from Skill.get_all instead of agent_schema.json
             skills_property = schema.get("properties", {}).get("skills", {})
-            skills_properties = skills_property.get("properties", {})
 
-            if skills_properties:
-                skill_states_map: dict[str, dict[str, Skill]] = {}
+            # Build skill_states_map from database
+            skill_states_map: dict[str, dict[str, Skill]] = {}
+            for skill_model in await Skill.get_all(db):
+                if not skill_model.config_name:
+                    continue
+                category_states = skill_states_map.setdefault(skill_model.category, {})
+                if skill_model.enabled:
+                    category_states[skill_model.config_name] = skill_model
+                else:
+                    category_states.pop(skill_model.config_name, None)
 
-                for skill_model in await Skill.get_all(db):
-                    if not skill_model.config_name:
-                        continue
-                    category_states = skill_states_map.setdefault(
-                        skill_model.category, {}
-                    )
-                    if skill_model.enabled:
-                        category_states[skill_model.config_name] = skill_model
-                    else:
-                        category_states.pop(skill_model.config_name, None)
+            enabled_categories = {
+                category for category, states in skill_states_map.items() if states
+            }
 
-                enabled_categories = {
-                    category for category, states in skill_states_map.items() if states
+            # Calculate price levels and skills data
+            category_avg_price_levels = {}
+            skills_data = {}
+            for category, states in skill_states_map.items():
+                if not states:
+                    continue
+                price_levels = [
+                    state.price_level
+                    for state in states.values()
+                    if state.price_level is not None
+                ]
+                if price_levels:
+                    category_avg_price_levels[category] = int(
+                        sum(price_levels) / len(price_levels)
+                    )
+                skills_data[category] = {
+                    config_name: state.price_level
+                    for config_name, state in states.items()
                 }
 
-                category_avg_price_levels = {}
-                skills_data = {}
-                for category, states in skill_states_map.items():
-                    if not states:
-                        continue
-                    price_levels = [
-                        state.price_level
-                        for state in states.values()
-                        if state.price_level is not None
-                    ]
-                    if price_levels:
-                        category_avg_price_levels[category] = int(
-                            sum(price_levels) / len(price_levels)
-                        )
-                    skills_data[category] = {
-                        config_name: state.price_level
-                        for config_name, state in states.items()
-                    }
+            # Dynamically generate skills_properties from Skill.get_all data
+            skills_properties = {}
+            current_dir = Path(__file__).parent
+
+            for category in enabled_categories:
+                # Skip if filtered for auto-generation
+                skill_schema_path = current_dir / f"../skills/{category}/schema.json"
+                if skill_schema_path.exists():
+                    try:
+                        with open(skill_schema_path) as f:
+                            skill_schema = json.load(f)
+
+                        # Check if this skill should be filtered for owner API requirements
+                        if filter_owner_api_skills and cls._is_agent_owner_only_skill(
+                            skill_schema
+                        ):
+                            logger.info(
+                                f"Filtered out skill '{category}' from auto-generation: requires agent owner API key"
+                            )
+                            continue
+
+                        # Create skill property with embedded schema instead of reference
+                        # Load and embed the full skill schema directly
+                        base_uri = f"file://{skill_schema_path}"
+                        with open(skill_schema_path) as f:
+                            embedded_skill_schema = jsonref.load(
+                                f, base_uri=base_uri, proxies=False, lazy_load=False
+                            )
 
-                skill_keys = list(skills_properties.keys())
-
-                for skill_category in skill_keys:
-                    if skill_category not in enabled_categories:
-                        skills_properties.pop(skill_category, None)
-                    elif filter_owner_api_skills and cls._is_agent_owner_only_skill(
-                        skills_properties[skill_category]
-                    ):
-                        skills_properties.pop(skill_category, None)
-                        logger.info(
-                            f"Filtered out skill '{skill_category}' from auto-generation: requires agent owner API key"
-                        )
-                    else:
-                        if skill_category in category_avg_price_levels:
-                            skills_properties[skill_category]["x-avg-price-level"] = (
-                                category_avg_price_levels[skill_category]
+                        skills_properties[category] = {
+                            "title": skill_schema.get("title", category.title()),
+                            **embedded_skill_schema,  # Embed the full schema instead of using $ref
+                        }
+
+                        # Add price level information
+                        if category in category_avg_price_levels:
+                            skills_properties[category]["x-avg-price-level"] = (
+                                category_avg_price_levels[category]
                             )
 
-                        if skill_category in skills_data:
+                        if category in skills_data:
+                            # Add price level to states in the embedded schema
                             skill_states = (
-                                skills_properties[skill_category]
+                                skills_properties[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_name in skills_data[category]
+                                    and skills_data[category][state_name] is not None
                                 ):
                                     state_config["x-price-level"] = skills_data[
-                                        skill_category
+                                        category
                                     ][state_name]
+                    except (FileNotFoundError, json.JSONDecodeError) as e:
+                        logger.warning(
+                            f"Could not load schema for skill category '{category}': {e}"
+                        )
+                        continue
+
+            # Update the skills property in the schema
+            if skills_property:
+                skills_property["properties"] = skills_properties
 
             # Log the changes for debugging
             logger.debug(

intentkit/models/agent_schema.json

@@ -321,152 +321,7 @@
       "description": "Dict of skills and their corresponding configurations",
       "x-group": "skills",
       "x-inline": true,
-      "properties": {
-        "allora": {
-          "title": "Allora",
-          "$ref": "../skills/allora/schema.json"
-        },
-        "cdp": {
-          "title": "Coinbase Wallet",
-          "$ref": "../skills/cdp/schema.json"
-        },
-        "dapplooker": {
-          "title": "DappLooker",
-          "$ref": "../skills/dapplooker/schema.json"
-        },
-        "elfa": {
-          "title": "Elfa",
-          "$ref": "../skills/elfa/schema.json"
-        },
-        "openai": {
-          "title": "OpenAI",
-          "$ref": "../skills/openai/schema.json"
-        },
-        "portfolio": {
-          "title": "Blockchain Portfolio",
-          "$ref": "../skills/portfolio/schema.json"
-        },
-        "tavily": {
-          "title": "Tavily",
-          "$ref": "../skills/tavily/schema.json"
-        },
-        "token": {
-          "title": "Token Operations",
-          "$ref": "../skills/token/schema.json"
-        },
-        "twitter": {
-          "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"
-        },
-        "dexscreener": {
-          "title": "DEX Screener",
-          "$ref": "../skills/dexscreener/schema.json"
-        },
-        "heurist": {
-          "title": "Heurist",
-          "$ref": "../skills/heurist/schema.json"
-        },
-        "nation": {
-          "title": "Nation",
-          "$ref": "../skills/nation/schema.json"
-        },
-        "defillama": {
-          "title": "Defillama",
-          "$ref": "../skills/defillama/schema.json"
-        },
-        "enso": {
-          "title": "Enso",
-          "$ref": "../skills/enso/schema.json"
-        },
-        "common": {
-          "title": "Common",
-          "$ref": "../skills/common/schema.json"
-        },
-        "github": {
-          "title": "GitHub",
-          "$ref": "../skills/github/schema.json"
-        },
-        "moralis": {
-          "title": "Moralis",
-          "$ref": "../skills/moralis/schema.json"
-        },
-        "system": {
-          "title": "System",
-          "$ref": "../skills/system/schema.json"
-        },
-        "http": {
-          "title": "HTTP Client",
-          "$ref": "../skills/http/schema.json"
-        },
-        "web_scraper": {
-          "title": "Web Scraper & Content Indexing",
-          "$ref": "../skills/web_scraper/schema.json"
-        },
-        "firecrawl": {
-          "title": "Firecrawl Web Scraping",
-          "$ref": "../skills/firecrawl/schema.json"
-        },
-        "aixbt": {
-          "title": "AIXBT",
-          "$ref": "../skills/aixbt/schema.json"
-        },
-        "cookiefun": {
-          "title": "cookie.fun",
-          "$ref": "../skills/cookiefun/schema.json"
-        },
-        "cryptocompare": {
-          "title": "Cryptocompare",
-          "$ref": "../skills/cryptocompare/schema.json"
-        },
-        "cryptopanic": {
-          "title": "CryptoPanic",
-          "$ref": "../skills/cryptopanic/schema.json"
-        },
-        "dune_analytics": {
-          "title": "Dune Analytics",
-          "$ref": "../skills/dune_analytics/schema.json"
-        },
-        "slack": {
-          "title": "Slack",
-          "$ref": "../skills/slack/schema.json"
-        },
-        "supabase": {
-          "title": "Supabase",
-          "$ref": "../skills/supabase/schema.json"
-        },
-        "venice_audio": {
-          "title": "Venice Audio",
-          "$ref": "../skills/venice_audio/schema.json"
-        },
-        "venice_image": {
-          "title": "Venice Image",
-          "$ref": "../skills/venice_image/schema.json"
-        },
-        "unrealspeech": {
-          "title": "UnrealSpeech",
-          "$ref": "../skills/unrealspeech/schema.json"
-        },
-        "carv": {
-          "title": "Carv",
-          "$ref": "../skills/carv/schema.json"
-        },
-        "lifi": {
-          "title": "LiFi",
-          "$ref": "../skills/lifi/schema.json"
-        },
-        "casino": {
-          "title": "Casino",
-          "$ref": "../skills/casino/schema.json"
-        }
-      }
+      "properties": {}
     },
     "autonomous": {
       "title": "Autonomous",

intentkit/models/llm.csv

@@ -1,4 +1,9 @@
 id,name,provider,enabled,input_price,output_price,price_level,context_length,output_length,intelligence,speed,supports_image_input,supports_skill_calls,supports_structured_output,has_reasoning,supports_search,supports_temperature,supports_frequency_penalty,supports_presence_penalty,api_base,timeout
+qwen/qwen3-235b-a22b-2507,Qwen3 235B A22B Instruct 2507,gatewayz,TRUE,0.1,0.6,1,262000,262000,4,2,FALSE,TRUE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE,https://api.gatewayz.ai/v1,300
+google/gemini-2.5-flash,Gemini 2.5 Flash,gatewayz,TRUE,0.3,2.5,2,1050000,65000,4,2,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE,https://api.gatewayz.ai/v1,300
+x-ai/grok-4-fast:free,Grok 4 Fast,gatewayz,TRUE,0.2,0.5,1,128000,30000,4,2,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE,https://api.gatewayz.ai/v1,300
+x-ai/grok-code-fast-1,Grok Code Fast 1,gatewayz,TRUE,3,15,5,200000,64000,5,1,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE,https://api.gatewayz.ai/v1,300
+anthropic/claude-sonnet-4,Anthropic Claude Sonnet 4,gatewayz,TRUE,3,15,5,200000,64000,5,1,TRUE,TRUE,FALSE,TRUE,FALSE,TRUE,FALSE,FALSE,https://api.gatewayz.ai/v1,300
 gpt-4o,GPT-4o,openai,FALSE,2.5,10,4,128000,4096,4,3,TRUE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,FALSE,,180
 gpt-4o-mini,GPT-4o Mini,openai,FALSE,0.15,0.6,1,128000,4096,3,4,FALSE,TRUE,TRUE,FALSE,TRUE,TRUE,FALSE,FALSE,,180
 gpt-4.1-nano,GPT-4.1 Nano,openai,TRUE,0.1,0.4,1,128000,4096,3,5,FALSE,TRUE,TRUE,FALSE,FALSE,TRUE,FALSE,FALSE,,180

intentkit/models/llm.py

@@ -95,6 +95,7 @@ class LLMProvider(str, Enum):
     OPENAI = "openai"
     DEEPSEEK = "deepseek"
     XAI = "xai"
+    GATEWAYZ = "gatewayz"
     ETERNAL = "eternal"
     REIGENT = "reigent"
     VENICE = "venice"
@@ -105,9 +106,10 @@ class LLMProvider(str, Enum):
             self.OPENAI: "OpenAI",
             self.DEEPSEEK: "DeepSeek",
             self.XAI: "xAI",
-            self.ETERNAL: "Others",
-            self.REIGENT: "Others",
-            self.VENICE: "Others",
+            self.GATEWAYZ: "Gatewayz",
+            self.ETERNAL: "Eternal",
+            self.REIGENT: "Reigent",
+            self.VENICE: "Venice",
         }
         return display_names.get(self, self.value)
 
@@ -462,6 +464,35 @@ class XAILLM(LLMModel):
         return ChatXAI(**kwargs)
 
 
+class GatewayzLLM(LLMModel):
+    """Gatewayz AI LLM configuration."""
+
+    async def create_instance(self, config: Any) -> BaseChatModel:
+        """Create and return a ChatOpenAI instance configured for Eternal AI."""
+        from langchain_openai import ChatOpenAI
+
+        info = await self.model_info()
+
+        kwargs = {
+            "model": self.model_name,
+            "api_key": config.gatewayz_api_key,
+            "base_url": info.api_base,
+            "timeout": info.timeout,
+        }
+
+        # Add optional parameters based on model support
+        if info.supports_temperature:
+            kwargs["temperature"] = self.temperature
+
+        if info.supports_frequency_penalty:
+            kwargs["frequency_penalty"] = self.frequency_penalty
+
+        if info.supports_presence_penalty:
+            kwargs["presence_penalty"] = self.presence_penalty
+
+        return ChatOpenAI(**kwargs)
+
+
 class EternalLLM(LLMModel):
     """Eternal AI LLM configuration."""
 
@@ -575,6 +606,8 @@ async def create_llm_model(
         return ReigentLLM(**base_params)
     elif provider == LLMProvider.VENICE:
         return VeniceLLM(**base_params)
+    elif provider == LLMProvider.GATEWAYZ:
+        return GatewayzLLM(**base_params)
     else:
         # Default to OpenAI
         return OpenAILLM(**base_params)

intentkit/skills/acolyt/schema.json

@@ -5,8 +5,9 @@
   "description": "Integration with Acolyt Oracle providing blockchain oracle services for accessing and verifying off-chain data with secure API connections",
   "x-icon": "https://ai.service.crestal.dev/skills/acolyt/acolyt.jpg",
   "x-tags": [
-    "Blockchain",
-    "Oracle"
+    "Analytics",
+    "Crypto",
+    "DeFi"
   ],
   "properties": {
     "enabled": {
@@ -86,4 +87,4 @@
     }
   },
   "additionalProperties": true
-}
+}

intentkit/skills/aixbt/schema.json

@@ -5,9 +5,9 @@
   "description": "Cryptocurrency project data and analytics through the AIXBT API",
   "x-icon": "https://ai.service.crestal.dev/skills/aixbt/aixbt.jpg",
   "x-tags": [
-    "Cryptocurrency",
-    "Research",
-    "Analytics"
+    "Analytics",
+    "Crypto",
+    "Knowledge Base"
   ],
   "properties": {
     "enabled": {
@@ -96,4 +96,4 @@
     }
   },
   "additionalProperties": true
-}
+}

intentkit/skills/allora/schema.json

@@ -5,7 +5,8 @@
   "description": "Integration with Allora API for blockchain-based price predictions and market forecasting services via Upshot's prediction markets",
   "x-icon": "https://ai.service.crestal.dev/skills/allora/allora.jpeg",
   "x-tags": [
-    "Blockchain"
+    "Analytics",
+    "Crypto"
   ],
   "properties": {
     "enabled": {
@@ -86,4 +87,4 @@
     }
   },
   "additionalProperties": true
-}
+}

intentkit/skills/basename/schema.json

@@ -5,7 +5,8 @@
   "description": "Basename ENS-style name registration via Coinbase AgentKit",
   "x-icon": "https://ai.service.crestal.dev/skills/basename/basename.svg",
   "x-tags": [
-    "Blockchain"
+    "Crypto",
+    "Identity"
   ],
   "properties": {
     "enabled": {