intentkit 0.12.1.dev1__tar.gz → 0.12.2__tar.gz

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/PKG-INFO

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

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

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/abstracts/graph.py

@@ -38,6 +38,7 @@ class AgentContext(BaseModel):
     is_private: bool
     thinking: bool = False
     payer: str | None = None
+    start_message_id: str = ""
 
     @property
     def agent(self) -> Agent:

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/config/config.py

@@ -204,6 +204,9 @@ class Config:
         self.tavily_api_key: str | None = self.load("TAVILY_API_KEY")
         self.cookiefun_api_key: str | None = self.load("COOKIEFUN_API_KEY")
         self.firecrawl_api_key: str | None = self.load("FIRECRAWL_API_KEY")
+        # Cloudflare Browser Rendering
+        self.cloudflare_account_id: str | None = self.load("CLOUDFLARE_ACCOUNT_ID")
+        self.cloudflare_api_token: str | None = self.load("CLOUDFLARE_API_TOKEN")
         # Sentry
         self.sentry_dsn: str | None = self.load("SENTRY_DSN")
         self.sentry_sample_rate: float = self.load_float("SENTRY_SAMPLE_RATE", 0.1)

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/core/credit/__init__.py

@@ -26,6 +26,7 @@ from .base import (
 from .expense import (
     expense_message,
     expense_skill,
+    expense_skill_internal_llm,
     expense_summarize,
     skill_cost,
 )
@@ -66,6 +67,7 @@ __all__ = [
     "adjustment",
     "expense_message",
     "expense_skill",
+    "expense_skill_internal_llm",
     "expense_summarize",
     "fetch_credit_event_by_id",
     "fetch_credit_event_by_upstream_tx_id",

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/core/credit/expense.py

@@ -28,6 +28,7 @@ from intentkit.models.credit import (
     TransactionType,
     UpstreamType,
 )
+from intentkit.models.llm import LLMModelInfo
 
 from .base import FOURPLACES, SkillCost
 
@@ -1030,3 +1031,56 @@ async def expense_summarize(
 
     # 6. Return credit event model
     return CreditEvent.model_validate(event)
+
+
+async def expense_skill_internal_llm(
+    user_id: str,
+    agent: Agent,
+    skill_name: str,
+    skill_call_id: str,
+    start_message_id: str,
+    model_id: str,
+    input_tokens: int,
+    output_tokens: int,
+    cached_input_tokens: int = 0,
+) -> None:
+    """
+    Bill for an LLM call made internally within a skill execution.
+
+    This is a convenience function for skills that need to call an LLM
+    (e.g. for content cleaning) and bill the user for the token cost.
+    It calculates the cost from token usage and creates a SKILL_CALL credit event.
+
+    Args:
+        user_id: ID of the user to charge
+        agent: Agent instance
+        skill_name: Name of the skill making the LLM call
+        skill_call_id: ID of the tool call (from LangChain runtime)
+        start_message_id: ID of the starting user message
+        model_id: ID of the LLM model used
+        input_tokens: Number of input tokens used
+        output_tokens: Number of output tokens used
+        cached_input_tokens: Number of cached input tokens used
+    """
+    from intentkit.config.db import get_session
+
+    model_info = await LLMModelInfo.get(model_id)
+    llm_cost = await model_info.calculate_cost(
+        input_tokens, output_tokens, cached_input_tokens
+    )
+
+    if llm_cost <= Decimal("0"):
+        return
+
+    async with get_session() as session:
+        await expense_skill(
+            session,
+            user_id,
+            "",  # no message_id available from within skill
+            start_message_id,
+            skill_call_id,
+            skill_name,
+            llm_cost,
+            agent,
+        )
+        await session.commit()

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/core/engine.py

@@ -214,6 +214,7 @@ async def build_executor(
             enable_post=enable_post,
             enable_long_term_memory=agent.enable_long_term_memory or False,
             enable_sub_agents=bool(agent.sub_agents),
+            search_internet=agent.search_internet,
         )
     )
 
@@ -607,6 +608,7 @@ async def stream_agent_raw(
         entrypoint=user_message.author_type,
         is_private=is_private,
         payer=payer if payment_enabled else None,
+        start_message_id=user_message.id,
     )
 
     # run

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/core/prompt.py

@@ -59,7 +59,7 @@ def _build_system_skills_section(agent: Agent, context: AgentContext) -> str:
         )
     if enable_activity:
         lines.append(
-            "- create_activity: Create a new activity on your timeline to record your actions.\n"
+            "- create_activity: Publish an activity to your public timeline. ONLY use when user explicitly requests it.\n"
             "- recent_activities: Retrieve your recent activities to maintain context.\n"
         )
     if agent.enable_long_term_memory:
@@ -74,7 +74,9 @@ def _build_system_skills_section(agent: Agent, context: AgentContext) -> str:
         cautions.append("create_activity")
     if cautions:
         lines.append(
-            f"\nIMPORTANT: Do not use {' or '.join(cautions)} unless the user explicitly asks you to do so.\n\n"
+            f"\nCRITICAL RULE: NEVER use {' or '.join(cautions)} unless the user EXPLICITLY asks you to create/publish. "
+            f"Do NOT use them proactively, even to log, summarize, or report what you did. "
+            f"Violation of this rule is a serious error.\n\n"
         )
     else:
         lines.append("\n")
@@ -319,7 +321,7 @@ def _build_autonomous_task_prompt(agent: Agent, context: AgentContext) -> str:
     task_info += (
         ". In autonomous task, you cannot ask the user for clarification or input. "
         "You must make all decisions on your own. "
-        "If an error prevents the task from proceeding, use create_activity to report the issue to the user"
+        "If an error prevents the task from proceeding, you may use create_activity to report the error only"
     )
 
     return f"{task_info}. "

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

@@ -9,6 +9,7 @@ from intentkit.core.system_skills.call_agent import CallAgentSkill
 from intentkit.core.system_skills.create_activity import CreateActivitySkill
 from intentkit.core.system_skills.create_post import CreatePostSkill
 from intentkit.core.system_skills.get_post import GetPostSkill
+from intentkit.core.system_skills.read_webpage import ReadWebpageSkill
 from intentkit.core.system_skills.recent_activities import RecentActivitiesSkill
 from intentkit.core.system_skills.recent_posts import RecentPostsSkill
 from intentkit.core.system_skills.update_memory import UpdateMemorySkill
@@ -19,6 +20,7 @@ __all__ = [
     "CreateActivitySkill",
     "CreatePostSkill",
     "GetPostSkill",
+    "ReadWebpageSkill",
     "RecentActivitiesSkill",
     "RecentPostsSkill",
     "UpdateMemorySkill",
@@ -31,6 +33,7 @@ _recent_activities = RecentActivitiesSkill()
 _create_post = CreatePostSkill()
 _get_post = GetPostSkill()
 _recent_posts = RecentPostsSkill()
+_read_webpage = ReadWebpageSkill()
 _update_memory = UpdateMemorySkill()
 
 
@@ -39,6 +42,7 @@ def get_system_skills(
     enable_post: bool = True,
     enable_long_term_memory: bool = False,
     enable_sub_agents: bool = False,
+    search_internet: bool = True,
 ) -> list[SystemSkill]:
     """Get system skills instances filtered by flags.
 
@@ -47,6 +51,7 @@ def get_system_skills(
         enable_post: Whether to include post skills. Defaults to True.
         enable_long_term_memory: Whether to include memory skill. Defaults to False.
         enable_sub_agents: Whether to include call_agent skill. Defaults to False.
+        search_internet: Whether to include read_webpage skill. Defaults to True.
     """
     skills: list[SystemSkill] = []
     if enable_sub_agents:
@@ -60,4 +65,9 @@ def get_system_skills(
         skills.append(_recent_posts)
     if enable_long_term_memory:
         skills.append(_update_memory)
+    if search_internet:
+        from intentkit.config.config import config
+
+        if config.cloudflare_account_id and config.cloudflare_api_token:
+            skills.append(_read_webpage)
     return skills

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/core/system_skills/create_activity.py

@@ -4,32 +4,50 @@ from typing import override
 
 from langchain_core.tools import ArgsSchema
 from langchain_core.tools.base import ToolException
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from intentkit.core.agent import get_agent
 from intentkit.core.agent_activity import create_agent_activity
 from intentkit.core.system_skills.base import SystemSkill
 from intentkit.models.agent_activity import AgentActivityCreate
+from intentkit.utils.opengraph import fetch_link_meta
 
 
 class CreateActivityInput(BaseModel):
     """Input schema for creating an agent activity."""
 
-    text: str = Field(..., description="Activity content")
-    images: list[str] | None = Field(default=None, description="Image URLs")
+    text: str = Field(..., description="Activity content, plain text, max 280 bytes")
+    images: list[str] | None = Field(
+        default=None, max_length=4, description="Image URLs"
+    )
+
+    @field_validator("text")
+    @classmethod
+    def text_max_280_bytes(cls, v: str) -> str:
+        if len(v.encode("utf-8")) > 280:
+            raise ValueError("text must be at most 280 bytes")
+        return v
+
     video: str | None = Field(default=None, description="Video URL")
-    post_id: str | None = Field(default=None, description="Related post ID")
+    link: str | None = Field(default=None, description="URL to share")
 
+    @field_validator("link")
+    @classmethod
+    def link_must_be_http(cls, v: str | None) -> str | None:
+        if v is not None and not v.startswith(("http://", "https://")):
+            raise ValueError("link must start with http:// or https://")
+        return v
 
-class CreateActivitySkill(SystemSkill):
-    """Skill for creating a new agent activity.
 
-    This skill allows an agent to create an activity with text content,
-    optional images, video, and a reference to a related post.
-    """
+class CreateActivitySkill(SystemSkill):
+    """Skill for creating a new agent activity."""
 
     name: str = "create_activity"
-    description: str = "Create an activity with text, optional images, video, or a related post reference."
+    description: str = (
+        "Publish an activity to your public timeline. "
+        "IMPORTANT: Only use this skill when the user EXPLICITLY asks you to create, publish, or post an activity. "
+        "Do NOT call this on your own initiative, even to log or summarize what you did."
+    )
     args_schema: ArgsSchema | None = CreateActivityInput
 
     @override
@@ -38,7 +56,7 @@ class CreateActivitySkill(SystemSkill):
         text: str,
         images: list[str] | None = None,
         video: str | None = None,
-        post_id: str | None = None,
+        link: str | None = None,
     ) -> str:
         """Create a new agent activity.
 
@@ -46,7 +64,7 @@ class CreateActivitySkill(SystemSkill):
             text: Content of the activity.
             images: Optional list of image URLs.
             video: Optional video URL.
-            post_id: Optional ID of a related post.
+            link: Optional URL to share.
 
         Returns:
             A message indicating success with the activity ID.
@@ -59,6 +77,12 @@ class CreateActivitySkill(SystemSkill):
             agent_name = agent.name if agent else None
             agent_picture = agent.picture if agent else None
 
+            link_meta = None
+            if link:
+                meta = await fetch_link_meta(link)
+                if meta:
+                    link_meta = meta.model_dump()
+
             activity_create = AgentActivityCreate(
                 agent_id=agent_id,
                 agent_name=agent_name,
@@ -66,7 +90,8 @@ class CreateActivitySkill(SystemSkill):
                 text=text,
                 images=images,
                 video=video,
-                post_id=post_id,
+                link=link,
+                link_meta=link_meta,
             )
 
             activity = await create_agent_activity(activity_create)

intentkit-0.12.2/intentkit/core/system_skills/read_webpage.py

@@ -0,0 +1,183 @@
+"""Skill for reading webpage content as markdown via Cloudflare Browser Rendering."""
+
+import logging
+import re
+from typing import Annotated, override
+
+import httpx
+from langchain_core.tools import ArgsSchema, InjectedToolCallId
+from langchain_core.tools.base import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.core.system_skills.base import SystemSkill
+
+logger = logging.getLogger(__name__)
+
+CLEAN_CONTENT_PROMPT = """\
+You are a content extractor. Given raw markdown converted from a webpage, \
+extract only the meaningful, readable content. Remove:
+- Navigation menus, headers, footers, sidebars
+- Cookie notices, ads, promotional banners
+- Repetitive links, social media buttons
+- Any boilerplate or non-content elements
+
+Return ONLY the clean, readable main content in markdown format. \
+Do not add any commentary or explanation."""
+
+
+class ReadWebpageInput(BaseModel):
+    """Input schema for reading a webpage."""
+
+    url: str = Field(..., description="The URL of the webpage to read")
+
+
+class ReadWebpageSkill(SystemSkill):
+    """Skill for reading webpage content as markdown.
+
+    Uses Cloudflare Browser Rendering REST API to fetch and convert
+    webpages to markdown format, then cleans the content with an LLM.
+    """
+
+    name: str = "read_webpage"
+    description: str = (
+        "Read a webpage and return its content as markdown. "
+        "Useful when you need to read and understand the content of a specific URL."
+    )
+    args_schema: ArgsSchema | None = ReadWebpageInput
+
+    @override
+    async def _arun(
+        self,
+        url: str,
+        tool_call_id: Annotated[str | None, InjectedToolCallId] = None,
+    ) -> str:
+        """Read a webpage and return its content as markdown.
+
+        Args:
+            url: The URL of the webpage to read.
+            tool_call_id: Injected by LangChain runtime.
+
+        Returns:
+            The webpage content converted to markdown.
+        """
+        try:
+            from intentkit.config.config import config
+
+            account_id = config.cloudflare_account_id
+            api_token = config.cloudflare_api_token
+            if not account_id or not api_token:
+                raise ToolException(
+                    "Cloudflare Browser Rendering is not configured. "
+                    "Set CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN."
+                )
+
+            # Fetch webpage as markdown via Cloudflare
+            raw_markdown = await self._fetch_markdown(account_id, api_token, url)
+            if not raw_markdown:
+                return "The webpage returned no content."
+
+            # Clean whitespace: collapse multiple spaces into one
+            cleaned = re.sub(r" {2,}", " ", raw_markdown)
+            # Also collapse 3+ consecutive newlines into 2
+            cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+
+            # Clean content with LLM
+            cleaned = await self._clean_with_llm(cleaned, tool_call_id)
+
+            # Truncate very long content
+            max_chars = 50000
+            if len(cleaned) > max_chars:
+                cleaned = cleaned[:max_chars] + "\n\n... (content truncated)"
+
+            return cleaned
+
+        except ToolException:
+            raise
+        except Exception as e:
+            logger.error(f"read_webpage failed: {e}", exc_info=True)
+            raise ToolException(f"Failed to read webpage: {e}") from e
+
+    async def _fetch_markdown(self, account_id: str, api_token: str, url: str) -> str:
+        """Fetch a URL and convert to markdown via Cloudflare Browser Rendering."""
+        api_url = f"https://api.cloudflare.com/client/v4/accounts/{account_id}/browser-rendering/markdown"
+
+        async with httpx.AsyncClient(timeout=60) as client:
+            response = await client.post(
+                api_url,
+                json={
+                    "url": url,
+                    "rejectRequestPattern": [".*\\.(css|ico|svg|woff2?|ttf|eot)$"],
+                },
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {api_token}",
+                },
+            )
+
+        if response.status_code != 200:
+            raise ToolException(
+                f"Cloudflare API returned status {response.status_code}: {response.text}"
+            )
+
+        data = response.json()
+        if not data.get("success"):
+            errors = data.get("errors", [])
+            raise ToolException(f"Cloudflare API error: {errors}")
+
+        return data.get("result", "")
+
+    async def _clean_with_llm(self, content: str, tool_call_id: str | None) -> str:
+        """Use a long-context LLM to extract readable content from raw markdown."""
+        from intentkit.models.llm import create_llm_model
+        from intentkit.models.llm_picker import pick_long_context_model
+
+        model_id = pick_long_context_model()
+        llm_model = await create_llm_model(model_id, temperature=0)
+        llm = await llm_model.create_instance()
+
+        response = await llm.ainvoke(
+            [
+                {"role": "system", "content": CLEAN_CONTENT_PROMPT},
+                {"role": "user", "content": content},
+            ]
+        )
+
+        # Bill for the LLM usage
+        input_tokens = (
+            response.usage_metadata.get("input_tokens", 0)
+            if response.usage_metadata
+            else 0
+        )
+        output_tokens = (
+            response.usage_metadata.get("output_tokens", 0)
+            if response.usage_metadata
+            else 0
+        )
+        cached_input_tokens = (
+            response.usage_metadata.get("input_token_details", {}).get("cache_read", 0)
+            if response.usage_metadata
+            else 0
+        )
+
+        try:
+            context = self.get_context()
+            payer = context.payer
+            if payer and tool_call_id:
+                from intentkit.core.credit.expense import expense_skill_internal_llm
+
+                await expense_skill_internal_llm(
+                    user_id=payer,
+                    agent=context.agent,
+                    skill_name=self.name,
+                    skill_call_id=tool_call_id,
+                    start_message_id=context.start_message_id,
+                    model_id=model_id,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    cached_input_tokens=cached_input_tokens,
+                )
+        except Exception as e:
+            logger.warning(f"Failed to bill for LLM cleaning: {e}")
+
+        result = response.content
+        return str(result) if result else content

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/models/agent_activity.py

@@ -5,7 +5,7 @@ from epyxid import XID
 from pydantic import BaseModel, ConfigDict
 from pydantic import Field as PydanticField
 from sqlalchemy import DateTime, String, func
-from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.dialects.postgresql import ARRAY, JSONB
 from sqlalchemy.orm import Mapped, mapped_column
 
 from intentkit.config.base import Base
@@ -24,6 +24,11 @@ class AgentActivityBase(BaseModel):
         list[str] | None, PydanticField(description="List of image URLs")
     ] = None
     video: Annotated[str | None, PydanticField(description="Video URL")] = None
+    link: Annotated[str | None, PydanticField(description="Link URL")] = None
+    link_meta: Annotated[
+        dict[str, str | None] | None,
+        PydanticField(description="Link metadata"),
+    ] = None
     post_id: Annotated[str | None, PydanticField(description="Related post ID")] = None
 
 
@@ -63,6 +68,10 @@ class AgentActivityTable(Base):
     video: Mapped[str | None] = mapped_column(
         String, nullable=True, comment="Video URL"
     )
+    link: Mapped[str | None] = mapped_column(String, nullable=True, comment="Link URL")
+    link_meta: Mapped[dict[str, str | None] | None] = mapped_column(
+        JSONB, nullable=True, comment="Link metadata"
+    )
     post_id: Mapped[str | None] = mapped_column(
         String, nullable=True, index=True, comment="Related post ID"
     )

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/intentkit/models/llm_picker.py

@@ -71,3 +71,32 @@ def pick_default_model() -> str:
             return model_id
 
     raise RuntimeError("No default model available: missing all required API keys")
+
+
+def pick_long_context_model() -> str:
+    """
+    Pick the cheapest available model with context length >= 1,000,000 tokens.
+    Falls back to any available model if no long-context model is configured.
+    """
+    # Priority order based on cost (cheapest first), one per provider:
+    order: list[tuple[str, LLMProvider]] = [
+        ("gemini-3.1-flash-lite-preview", LLMProvider.GOOGLE),
+        ("grok-4-1-fast-non-reasoning", LLMProvider.XAI),
+        ("qwen/qwen3.5-flash-02-23", LLMProvider.OPENROUTER),
+        ("gpt-5-nano", LLMProvider.OPENAI),
+        ("deepseek-chat", LLMProvider.DEEPSEEK),
+    ]
+
+    for model_id, provider in order:
+        if provider == LLMProvider.OPENAI and config.openai_api_key:
+            return model_id
+        if provider == LLMProvider.GOOGLE and config.google_api_key:
+            return model_id
+        if provider == LLMProvider.OPENROUTER and config.openrouter_api_key:
+            return model_id
+        if provider == LLMProvider.XAI and config.xai_api_key:
+            return model_id
+        if provider == LLMProvider.DEEPSEEK and config.deepseek_api_key:
+            return model_id
+
+    raise RuntimeError("No long-context model available: missing all required API keys")

intentkit-0.12.2/intentkit/utils/opengraph.py

@@ -0,0 +1,108 @@
+"""OpenGraph metadata fetcher utility."""
+
+from html.parser import HTMLParser
+from urllib.parse import urljoin, urlparse
+
+import httpx
+from pydantic import BaseModel
+
+
+class LinkMeta(BaseModel):
+    """OpenGraph link metadata."""
+
+    title: str | None = None
+    description: str | None = None
+    image: str | None = None
+    favicon: str | None = None
+
+
+class _OGParser(HTMLParser):
+    """Parse HTML for OpenGraph meta tags and favicon link tags."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.og: dict[str, str] = {}
+        self.favicon: str | None = None
+        self.title: str | None = None
+        self._in_title = False
+        self._title_parts: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attr_dict = {k: v for k, v in attrs if v is not None}
+
+        if tag == "meta":
+            prop = attr_dict.get("property", "")
+            name = attr_dict.get("name", "")
+            content = attr_dict.get("content", "")
+            if prop in ("og:title", "og:description", "og:image"):
+                self.og[prop] = content
+            elif name in ("description",) and "og:description" not in self.og:
+                self.og["og:description"] = content
+
+        elif tag == "link":
+            rel = attr_dict.get("rel", "")
+            href = attr_dict.get("href")
+            if href and ("icon" in rel):
+                self.favicon = href
+
+        elif tag == "title":
+            self._in_title = True
+            self._title_parts = []
+
+    def handle_data(self, data: str) -> None:
+        if self._in_title:
+            self._title_parts.append(data)
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag == "title" and self._in_title:
+            self._in_title = False
+            self.title = "".join(self._title_parts).strip()
+
+
+async def fetch_link_meta(url: str) -> LinkMeta | None:
+    """Fetch OpenGraph metadata from a URL.
+
+    Args:
+        url: The URL to fetch metadata from.
+
+    Returns:
+        LinkMeta with extracted metadata, or None on any error.
+    """
+    try:
+        async with httpx.AsyncClient(
+            timeout=5.0,
+            follow_redirects=True,
+            headers={
+                "User-Agent": (
+                    "Mozilla/5.0 (compatible; IntentKit/1.0; +https://intentkit.io)"
+                ),
+            },
+        ) as client:
+            resp = await client.get(url)
+            resp.raise_for_status()
+
+        parser = _OGParser()
+        parser.feed(resp.text)
+
+        origin = f"{urlparse(url).scheme}://{urlparse(url).netloc}"
+
+        # Resolve favicon
+        favicon = parser.favicon
+        if favicon:
+            favicon = urljoin(url, favicon)
+        else:
+            favicon = f"{origin}/favicon.ico"
+
+        # Resolve image
+        image = parser.og.get("og:image")
+        if image:
+            image = urljoin(url, image)
+
+        return LinkMeta(
+            title=parser.og.get("og:title") or parser.title,
+            description=parser.og.get("og:description"),
+            image=image,
+            favicon=favicon,
+        )
+    except Exception:
+        return None

{intentkit-0.12.1.dev1 → intentkit-0.12.2}/pyproject.toml

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