intentkit 0.6.9.dev2__tar.gz → 0.6.10.dev2__tar.gz

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.9.dev2
+Version: 0.6.10.dev2
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit
@@ -64,8 +64,8 @@ Requires-Dist: langchain-xai>=0.2.1
 Requires-Dist: langchain<0.4.0,>=0.3.25
 Requires-Dist: langgraph-checkpoint-postgres<2.0.23,>=2.0.16
 Requires-Dist: langgraph-checkpoint>=2.0.18
-Requires-Dist: langgraph-prebuilt<0.6.0,>=0.5.1
-Requires-Dist: langgraph<0.6.0,>=0.5.1
+Requires-Dist: langgraph-prebuilt<0.7.0,>=0.6.1
+Requires-Dist: langgraph<0.7.0,>=0.6.1
 Requires-Dist: langmem>=0.0.27
 Requires-Dist: mypy-boto3-s3<2.0.0,>=1.37.24
 Requires-Dist: openai>=1.59.6

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.9-dev2"
+__version__ = "0.6.10-dev2"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/abstracts/graph.py

@@ -1,7 +1,11 @@
+import asyncio
 from enum import Enum
-from typing import Any, Callable, Dict, NotRequired
+from typing import Any, Dict, Literal, NotRequired, Optional
 
 from langgraph.prebuilt.chat_agent_executor import AgentState as BaseAgentState
+from pydantic import BaseModel
+
+from intentkit.models.agent import Agent
 
 
 class AgentError(str, Enum):
@@ -22,4 +26,15 @@ class AgentState(BaseAgentState):
     __extra__: NotRequired[Dict[str, Any]]
 
 
-MemoryManager = Callable[[AgentState], AgentState]
+class AgentContext(BaseModel):
+    agent_id: str
+    chat_id: str
+    user_id: Optional[str] = None
+    app_id: Optional[str] = None
+    entrypoint: Literal["web", "twitter", "telegram", "trigger", "api"]
+    is_private: bool
+    payer: Optional[str] = None
+
+    @property
+    def agent(self) -> Agent:
+        return asyncio.run(Agent.get(self.agent_id))

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/core/engine.py

@@ -27,15 +27,15 @@ from langchain_core.messages import (
     HumanMessage,
 )
 from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
 from langgraph.errors import GraphRecursionError
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.prebuilt import create_react_agent
+from langgraph.runtime import Runtime
 from sqlalchemy import func, update
 from sqlalchemy.exc import SQLAlchemyError
 
-from intentkit.abstracts.graph import AgentError, AgentState
+from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
 from intentkit.config.config import config
 from intentkit.core.credit import expense_message, expense_skill
 from intentkit.core.node import PreModelNode, post_model_node
@@ -201,11 +201,13 @@ async def create_agent(
     prompt_temp = ChatPromptTemplate.from_messages(prompt_array)
 
     async def formatted_prompt(
-        state: AgentState, config: RunnableConfig
+        state: AgentState, runtime: Runtime[AgentContext]
     ) -> list[BaseMessage]:
         final_system_prompt = escaped_prompt
-        if config.get("configurable") and config["configurable"].get("entrypoint"):
-            entrypoint = config["configurable"]["entrypoint"]
+        context = runtime.context
+        logger.debug(f"formatted_prompt, context: {context}")
+        if context.entrypoint:
+            entrypoint = context.entrypoint
             entrypoint_prompt = None
             if (
                 agent.twitter_entrypoint_enabled
@@ -222,11 +224,7 @@ async def create_agent(
                 entrypoint_prompt = agent.telegram_entrypoint_prompt
                 logger.debug("telegram entrypoint prompt added")
             elif entrypoint == AuthorType.TRIGGER.value:
-                task_id = (
-                    config["configurable"]
-                    .get("chat_id", "")
-                    .removeprefix("autonomous-")
-                )
+                task_id = context.chat_id.removeprefix("autonomous-")
                 # Find the autonomous task by task_id
                 autonomous_task = None
                 if agent.autonomous:
@@ -263,20 +261,15 @@ async def create_agent(
             if entrypoint_prompt:
                 entrypoint_prompt = await explain_prompt(entrypoint_prompt)
                 final_system_prompt = f"{final_system_prompt}## Entrypoint rules\n\n{entrypoint_prompt}\n\n"
-        if config.get("configurable"):
-            final_system_prompt = f"{final_system_prompt}## Internal Info\n\n"
-            "These are for your internal use. You can use them when querying or storing data, "
-            "but please do not directly share this information with users.\n\n"
-            chat_id = config["configurable"].get("chat_id")
-            if chat_id:
-                final_system_prompt = f"{final_system_prompt}chat_id: {chat_id}\n\n"
-            user_id = config["configurable"].get("user_id")
-            if user_id:
-                final_system_prompt = f"{final_system_prompt}user_id: {user_id}\n\n"
+        final_system_prompt = f"{final_system_prompt}## Internal Info\n\n"
+        "These are for your internal use. You can use them when querying or storing data, "
+        "but please do not directly share this information with users.\n\n"
+        final_system_prompt = f"{final_system_prompt}chat_id: {context.chat_id}\n\n"
+        if context.user_id:
+            final_system_prompt = f"{final_system_prompt}user_id: {context.user_id}\n\n"
         system_prompt = [("system", final_system_prompt)]
         return prompt_temp.invoke(
-            {"messages": state["messages"], "system_prompt": system_prompt},
-            config,
+            {"messages": state["messages"], "system_prompt": system_prompt}
         )
 
     # log final prompt and all skills
@@ -304,6 +297,7 @@ async def create_agent(
         pre_model_hook=pre_model_hook,
         post_model_hook=post_model_node if config.payment_enabled else None,
         state_schema=AgentState,
+        context_schema=AgentContext,
         checkpointer=memory,
         debug=config.debug_checkpoint,
         name=agent.id,
@@ -585,22 +579,27 @@ async def stream_agent(message: ChatMessageCreate):
     thread_id = f"{input.agent_id}-{input.chat_id}"
     stream_config = {
         "configurable": {
-            "agent_id": agent.id,
             "thread_id": thread_id,
-            "chat_id": input.chat_id,
-            "user_id": input.user_id,
-            "app_id": input.app_id,
-            "entrypoint": input.author_type,
-            "is_private": is_private,
-            "payer": payer if payment_enabled else None,
         },
         "recursion_limit": recursion_limit,
     }
 
+    context = AgentContext(
+        agent_id=input.agent_id,
+        chat_id=input.chat_id,
+        user_id=input.user_id,
+        app_id=input.app_id,
+        entrypoint=input.author_type,
+        is_private=is_private,
+        payer=payer if payment_enabled else None,
+    )
+
     # run
     cached_tool_step = None
     try:
-        async for chunk in executor.astream({"messages": messages}, stream_config):
+        async for chunk in executor.astream(
+            {"messages": messages}, context=context, config=stream_config
+        ):
             this_time = time.perf_counter()
             logger.debug(f"stream chunk: {chunk}", extra={"thread_id": thread_id})
             if "agent" in chunk and "messages" in chunk["agent"]:
@@ -728,6 +727,26 @@ async def stream_agent(message: ChatMessageCreate):
                                     skill_call["response"] = textwrap.shorten(
                                         str(msg.content), width=1000, placeholder="..."
                                     )
+                                if msg.artifact:
+                                    artifact_message_create = ChatMessageCreate(
+                                        id=str(XID()),
+                                        agent_id=input.agent_id,
+                                        chat_id=input.chat_id,
+                                        user_id=input.user_id,
+                                        author_id=input.agent_id,
+                                        author_type=AuthorType.SKILL,
+                                        model=agent.model,
+                                        thread_type=input.author_type,
+                                        reply_to=input.id,
+                                        message="",
+                                        attachments=msg.artifact,
+                                        time_cost=this_time - last,
+                                    )
+                                    artifact_message = (
+                                        await artifact_message_create.save()
+                                    )
+                                    yield artifact_message
+                                    last = this_time
                             skill_calls.append(skill_call)
                             break
                 skill_message_create = ChatMessageCreate(

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/core/node.py

@@ -11,8 +11,8 @@ from langchain_core.messages import (
     ToolMessage,
 )
 from langchain_core.messages.utils import count_tokens_approximately, trim_messages
-from langchain_core.runnables import RunnableConfig
 from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.runtime import get_runtime
 from langgraph.utils.runnable import RunnableCallable
 from langmem.short_term.summarization import (
     DEFAULT_EXISTING_SUMMARY_PROMPT,
@@ -21,9 +21,8 @@ from langmem.short_term.summarization import (
     SummarizationResult,
     asummarize_messages,
 )
-from pydantic import BaseModel
 
-from intentkit.abstracts.graph import AgentError, AgentState
+from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
 from intentkit.core.credit import skill_cost
 from intentkit.models.agent import Agent
 from intentkit.models.credit import CreditAccount, OwnerType
@@ -108,11 +107,7 @@ class PreModelNode(RunnableCallable):
     def _func(self, AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(
-        self,
-        input: AgentState,
-        config: RunnableConfig,
-    ) -> dict[str, Any]:
+    async def _afunc(self, input: AgentState) -> dict[str, Any]:
         messages, context = self._parse_input(input)
         try:
             _validate_chat_history(messages)
@@ -180,28 +175,23 @@ class PostModelNode(RunnableCallable):
         super().__init__(self._func, self._afunc, name="post_model_node", trace=False)
         self.func_accepts_config = True
 
-    def _func(self, input: dict[str, Any] | BaseModel) -> dict[str, Any]:
+    def _func(self, input: AgentState) -> dict[str, Any]:
         raise NotImplementedError("Not implemented yet")
 
-    async def _afunc(
-        self,
-        input: AgentState,
-        config: RunnableConfig,
-    ) -> dict[str, Any]:
-        logger.debug(f"Running PostModelNode, input: {input}, config: {config}")
+    async def _afunc(self, input: AgentState) -> dict[str, Any]:
+        runtime = get_runtime(AgentContext)
+        context = runtime.context
+        logger.debug(f"Running PostModelNode, input: {input}, context: {context}")
         state_update = {}
         messages = input.get("messages")
         if messages is None or not isinstance(messages, list) or len(messages) == 0:
             raise ValueError("Missing required field `messages` in the input.")
-        cfg = config.get("configurable")
-        if not config:
-            raise ValueError("Missing required field `configurable` in the config.")
-        payer = cfg.get("payer")
+        payer = context.payer
         if not payer:
             return state_update
         logger.debug(f"last: {messages[-1]}")
         msg = messages[-1]
-        agent_id = cfg.get("agent_id")
+        agent_id = context.agent_id
         agent = await Agent.get(agent_id)
         account = await CreditAccount.get_or_create(OwnerType.USER, payer)
         if hasattr(msg, "tool_calls") and msg.tool_calls:

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/models/agent.py

@@ -1285,6 +1285,9 @@ class Agent(AgentCreate):
                 return None
             return cls.model_validate(item)
 
+    def skill_config(self, category: str) -> Dict[str, Any]:
+        return self.skills.get(category, {}) if self.skills else {}
+
 
 class AgentResponse(BaseModel):
     """Response model for Agent API."""

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/models/chat.py

@@ -31,6 +31,7 @@ class ChatMessageAttachmentType(str, Enum):
     LINK = "link"
     IMAGE = "image"
     FILE = "file"
+    XMTP = "xmtp"
 
 
 class AuthorType(str, Enum):
@@ -61,13 +62,20 @@ class ChatMessageAttachment(TypedDict):
         ),
     ]
     url: Annotated[
-        str,
+        Optional[str],
         Field(
             ...,
             description="URL of the attachment",
             examples=["https://example.com/image.jpg"],
         ),
     ]
+    json: Annotated[
+        Optional[dict],
+        Field(
+            None,
+            description="JSON data of the attachment",
+        ),
+    ]
 
 
 class ChatMessageSkillCall(TypedDict):

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.9-dev2"
+version = "0.6.10-dev2"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"
@@ -33,10 +33,10 @@ dependencies = [
     "langchain-openai>=0.3.8",
     "langchain-text-splitters>=0.3.8",
     "langchain-xai>=0.2.1",
-    "langgraph (>=0.5.1,<0.6.0)",
+    "langgraph (>=0.6.1,<0.7.0)",
     "langgraph-checkpoint>=2.0.18",
     "langgraph-checkpoint-postgres>=2.0.16,<2.0.23",
-    "langgraph-prebuilt (>=0.5.1,<0.6.0)",
+    "langgraph-prebuilt (>=0.6.1,<0.7.0)",
     "langmem>=0.0.27",
     "mypy-boto3-s3>=1.37.24,<2.0.0",
     "openai>=1.59.6",

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/skills/acolyt/ask.py

@@ -2,7 +2,6 @@ import logging
 from typing import Dict, Literal, Type
 
 import httpx
-from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.acolyt.base import AcolytBaseTool
@@ -67,12 +66,11 @@ class AcolytAskGpt(AcolytBaseTool):
         """
     args_schema: Type[BaseModel] = AcolytAskGptInput
 
-    async def _arun(self, question: str, config: RunnableConfig, **kwargs) -> Dict:
+    async def _arun(self, question: str, **kwargs) -> Dict:
         """Run the tool to get answer from Acolyt GPT.
 
         Args:
             question (str): The question body from user.
-            config (RunnableConfig): The configuration for the runnable, containing agent context.
 
         Returns:
             Dict: The response from the API with message content.
@@ -80,8 +78,7 @@ class AcolytAskGpt(AcolytBaseTool):
         Raises:
             Exception: If there's an error accessing the Acolyt API.
         """
-        context = self.context_from_config(config)
-        api_key = self.get_api_key(context)
+        api_key = self.get_api_key()
         if not api_key:
             raise ValueError("Acolyt API key not found")
 

intentkit-0.6.10.dev2/skills/acolyt/base.py

@@ -0,0 +1,38 @@
+from typing import Type
+
+from langchain.tools.base import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+base_url = "https://acolyt-oracle-poc.vercel.app"
+
+
+class AcolytBaseTool(IntentKitSkill):
+    """Base class for Acolyt tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    def get_api_key(self) -> str:
+        context = self.get_context()
+        skill_config = context.agent.skill_config(self.category)
+        api_key_provider = skill_config.get("api_key_provider")
+        if api_key_provider == "platform":
+            return self.skill_store.get_system_config("acolyt_api_key")
+        # for backward compatibility, may only have api_key in skill_config
+        elif skill_config.get("api_key"):
+            return skill_config.get("api_key")
+        else:
+            raise ToolException(
+                f"Invalid API key provider: {api_key_provider}, or no api_key in config"
+            )
+
+    @property
+    def category(self) -> str:
+        return "acolyt"

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/skills/aixbt/__init__.py

@@ -48,7 +48,6 @@ async def get_skills(
         get_aixbt_skill(
             name=name,
             store=store,
-            api_key=config.get("api_key", ""),
         )
         for name in available_skills
     ]
@@ -57,17 +56,14 @@ async def get_skills(
 def get_aixbt_skill(
     name: str,
     store: SkillStoreABC,
-    api_key: str = "",
 ) -> AIXBTBaseTool:
     """Get an AIXBT API skill by name."""
-    cache_key = f"{name}:{api_key}"
 
     if name == "aixbt_projects":
-        if cache_key not in _cache:
-            _cache[cache_key] = AIXBTProjects(
+        if name not in _cache:
+            _cache[name] = AIXBTProjects(
                 skill_store=store,
-                api_key=api_key,
             )
-        return _cache[cache_key]
+        return _cache[name]
     else:
         raise ValueError(f"Unknown AIXBT skill: {name}")

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/skills/aixbt/projects.py

@@ -1,9 +1,8 @@
 import logging
-import os
 from typing import Any, Dict, Optional, Type
 
 import httpx
-from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.skills.aixbt.base import AIXBTBaseTool
@@ -55,11 +54,9 @@ class AIXBTProjects(AIXBTBaseTool):
         "for accessing AIXBT's specific dataset for crypto research."
     )
     args_schema: Type[BaseModel] = ProjectsInput
-    api_key: str = ""
 
     async def _arun(
         self,
-        config: RunnableConfig,
         limit: int = 10,
         name: Optional[str] = None,
         ticker: Optional[str] = None,
@@ -83,34 +80,27 @@ class AIXBTProjects(AIXBTBaseTool):
             JSON response with project data
         """
         # Get context from the config
-        context = self.context_from_config(config)
+        context = self.get_context()
+        skill_config = context.agent.skill_config(self.category)
         logger.debug(f"aixbt_projects.py: Running search with context {context}")
 
         # Check for rate limiting if configured
-        if context.config.get("rate_limit_number") and context.config.get(
+        if skill_config.get("rate_limit_number") and skill_config.get(
             "rate_limit_minutes"
         ):
             await self.user_rate_limit_by_category(
                 context.user_id,
-                context.config["rate_limit_number"],
-                context.config["rate_limit_minutes"],
+                skill_config["rate_limit_number"],
+                skill_config["rate_limit_minutes"],
             )
 
         # Get the API key from the agent's configuration
-        api_key = context.config.get("api_key")
+        api_key = skill_config.get("api_key")
 
-        # If not available in config, try the instance attribute (for backward compatibility)
         if not api_key:
-            api_key = self.api_key
-
-        # If still not available, try environment variable as last resort
-        if not api_key:
-            api_key = os.environ.get("AIXBT_API_KEY")
-
-        if not api_key:
-            return {
-                "error": "AIXBT API key is not available. Please provide it in the agent configuration."
-            }
+            raise ToolException(
+                "AIXBT API key is not available. Please provide it in the agent configuration."
+            )
 
         base_url = "https://api.aixbt.tech/v1/projects"
 
@@ -134,20 +124,6 @@ class AIXBTProjects(AIXBTBaseTool):
                 response = await client.get(base_url, params=params, headers=headers)
                 response.raise_for_status()
                 return response.json()
-        except httpx.HTTPStatusError as e:
-            logger.error(
-                f"aixbt_projects.py: HTTP error occurred: {e.response.status_code} - {e.response.text}"
-            )
-            return {
-                "error": f"HTTP error occurred: {e.response.status_code}",
-                "details": e.response.text,
-            }
-        except httpx.RequestError as e:
-            logger.error(f"aixbt_projects.py: Request error occurred: {str(e)}")
-            return {"error": f"Request error occurred: {str(e)}"}
         except Exception as e:
-            logger.error(
-                f"aixbt_projects.py: An unexpected error occurred: {str(e)}",
-                exc_info=True,
-            )
-            return {"error": f"An unexpected error occurred: {str(e)}"}
+            logger.error(f"Error getting projects: {str(e)}")
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

intentkit-0.6.10.dev2/skills/allora/base.py

@@ -0,0 +1,38 @@
+from typing import Type
+
+from langchain.tools.base import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+base_url = "https://api.upshot.xyz/v2/allora"
+
+
+class AlloraBaseTool(IntentKitSkill):
+    """Base class for Allora tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    def get_api_key(self) -> str:
+        context = self.get_context()
+        skill_config = context.agent.skill_config(self.category)
+        api_key_provider = skill_config.get("api_key_provider")
+        if api_key_provider == "platform":
+            return self.skill_store.get_system_config("allora_api_key")
+        # for backward compatibility, may only have api_key in skill_config
+        elif skill_config.get("api_key"):
+            return skill_config.get("api_key")
+        else:
+            raise ToolException(
+                f"Invalid API key provider: {api_key_provider}, or no api_key in config"
+            )
+
+    @property
+    def category(self) -> str:
+        return "allora"

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/skills/allora/price.py

@@ -2,7 +2,6 @@ from typing import Literal, Type
 
 import httpx
 from langchain.tools.base import ToolException
-from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.allora.base import AlloraBaseTool
@@ -84,7 +83,7 @@ class AlloraGetPrice(AlloraBaseTool):
         raise NotImplementedError("Use _arun instead")
 
     async def _arun(
-        self, token: str, time_frame: str, config: RunnableConfig, **kwargs
+        self, token: str, time_frame: str, **kwargs
     ) -> AlloraGetPriceOutput:
         """Run the tool to get the token price prediction from Allora API.
         Args:
@@ -98,8 +97,7 @@ class AlloraGetPrice(AlloraBaseTool):
         Raises:
             Exception: If there's an error accessing the Allora API.
         """
-        context = self.context_from_config(config)
-        api_key = self.get_api_key(context)
+        api_key = self.get_api_key()
         if not api_key:
             raise ValueError("Allora API key not found")
 

{intentkit-0.6.9.dev2 → intentkit-0.6.10.dev2}/skills/base.py

@@ -5,6 +5,7 @@ from typing import Any, Callable, Dict, Literal, NotRequired, Optional, TypedDic
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
 from langchain_core.tools.base import ToolException
+from langgraph.runtime import get_runtime
 from pydantic import (
     BaseModel,
     ValidationError,
@@ -13,12 +14,14 @@ from pydantic.v1 import ValidationError as ValidationErrorV1
 from redis.exceptions import RedisError
 
 from intentkit.abstracts.exception import RateLimitExceeded
+from intentkit.abstracts.graph import AgentContext
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.models.agent import Agent
 from intentkit.models.redis import get_redis
 
 SkillState = Literal["disabled", "public", "private"]
 SkillOwnerState = Literal["disabled", "private"]
+APIKeyProviderValue = Literal["platform", "agent_owner"]
 
 
 class SkillConfig(TypedDict):
@@ -26,7 +29,7 @@ class SkillConfig(TypedDict):
 
     enabled: bool
     states: Dict[str, SkillState | SkillOwnerState]
-    api_key_provider: NotRequired[str]
+    api_key_provider: NotRequired[APIKeyProviderValue]
     __extra__: NotRequired[Dict[str, Any]]
 
 
@@ -192,3 +195,7 @@ class IntentKitSkill(BaseTool):
             entrypoint=configurable.get("entrypoint"),
             is_private=configurable.get("is_private"),
         )
+
+    def get_context(self) -> AgentContext:
+        runtime = get_runtime(AgentContext)
+        return runtime.context