intentkit 0.17.43__tar.gz → 0.17.45__tar.gz

{intentkit-0.17.43 → intentkit-0.17.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.17.43
+Version: 0.17.45
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit
@@ -60,7 +60,7 @@ Requires-Dist: langchain-core>=0.3.43
 Requires-Dist: langchain-deepseek>=0.1.4
 Requires-Dist: langchain-google-genai>=3.2.0
 Requires-Dist: langchain-openai>=0.3.8
-Requires-Dist: langchain-openrouter>=0.0.2
+Requires-Dist: langchain-openrouter>=0.2.1
 Requires-Dist: langchain-text-splitters>=0.3.8
 Requires-Dist: langchain-xai>=0.2.1
 Requires-Dist: langchain>=0.3.25
@@ -71,7 +71,7 @@ Requires-Dist: langgraph>=0.6.1
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: mypy-boto3-s3<2.0.0,>=1.37.24
 Requires-Dist: openai>=1.59.6
-Requires-Dist: openrouter<0.8.0
+Requires-Dist: openrouter>=0.9.0
 Requires-Dist: pillow<13.0.0,>=11.1.0
 Requires-Dist: psycopg-pool>=3.2.4
 Requires-Dist: psycopg>=3.2.9

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/__init__.py

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

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/core/agent/__init__.py

@@ -5,7 +5,13 @@ from .analytics import (
     update_agents_assets,
     update_agents_statistics,
 )
-from .management import create_agent, deploy_agent, override_agent, patch_agent
+from .management import (
+    backfill_agent_avatar,
+    create_agent,
+    deploy_agent,
+    override_agent,
+    patch_agent,
+)
 from .notifications import send_agent_notification
 from .public_info import override_public_info, update_public_info
 from .queries import get_agent, get_agent_by_id_or_slug, iterate_agent_id_batches
@@ -21,6 +27,7 @@ __all__ = [
     "override_agent",
     "patch_agent",
     "create_agent",
+    "backfill_agent_avatar",
     "deploy_agent",
     "agent_action_cost",
     "update_agent_action_cost",

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/core/agent/management.py

@@ -1,6 +1,6 @@
 import logging
 
-from sqlalchemy import func, select
+from sqlalchemy import func, or_, select, update
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -320,6 +320,50 @@ async def create_agent(agent: AgentCreate) -> tuple[Agent, AgentData]:
     return latest_agent, agent_data
 
 
+async def backfill_agent_avatar(agent_id: str) -> None:
+    """Generate an avatar for an agent and write it back if still empty.
+
+    Intended to be scheduled as a background task after agent create/override/
+    patch. No-ops (and swallows all errors) if the agent is gone, already has a
+    picture, or the generation/upload fails.
+    """
+    # Deferred import: intentkit.core.avatar pulls in heavy optional deps
+    # (PIL, google.genai, openai) that would otherwise load on every cold
+    # start of any service importing core.agent.
+    from intentkit.core.avatar import generate_avatar
+
+    async with get_session() as db:
+        db_agent = await db.get(AgentTable, agent_id)
+        if not db_agent or db_agent.picture:
+            return
+        agent_snapshot = Agent.model_validate(db_agent)
+
+    try:
+        avatar_path = await generate_avatar(agent_id, agent_snapshot)
+    except Exception as e:
+        logger.warning("Agent avatar backfill generate failed for %s: %s", agent_id, e)
+        return
+    if not avatar_path:
+        return
+
+    try:
+        async with get_session() as db:
+            # Match both NULL and empty-string so a prior PATCH that cleared the
+            # column to "" still gets backfilled; the scheduling sites treat
+            # empty string as missing, and the write must agree.
+            await db.execute(
+                update(AgentTable)
+                .where(
+                    AgentTable.id == agent_id,
+                    or_(AgentTable.picture.is_(None), AgentTable.picture == ""),
+                )
+                .values(picture=avatar_path)
+            )
+            await db.commit()
+    except Exception as e:
+        logger.warning("Agent avatar backfill write failed for %s: %s", agent_id, e)
+
+
 async def deploy_agent(
     agent_id: str, agent: AgentUpdate, owner: str | None = None
 ) -> tuple[Agent, AgentData]:

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/core/avatar.py

@@ -4,6 +4,7 @@ import logging
 from typing import Any
 
 import httpx
+import openrouter
 from google import genai
 from google.genai import types
 from openai import AsyncOpenAI
@@ -14,6 +15,8 @@ from intentkit.config.config import config
 
 logger = logging.getLogger(__name__)
 
+OPENROUTER_IMAGE_MODEL = "bytedance-seed/seedream-4.5"
+
 # Prompt fields to extract from agent objects for avatar generation.
 # These are (field_name, display_label) pairs.
 _PROMPT_FIELDS: list[tuple[str, str]] = [
@@ -81,27 +84,75 @@ async def _download_image(url: str) -> bytes:
 
 
 async def generate_image_openrouter(prompt: str) -> bytes | None:
-    """Generate image using OpenRouter with bytedance-seed/seedream-4.5."""
+    """Generate image using OpenRouter (bytedance-seed/seedream-4.5).
+
+    OpenRouter does not expose an OpenAI-compatible `/images/generations`
+    endpoint; image generation routes through chat completions with the
+    `modalities` parameter. Image-only models reject `["image", "text"]`,
+    so we ask for `["image"]` which is accepted by all image-output models.
+    """
     try:
-        client = AsyncOpenAI(
+        client = openrouter.OpenRouter(
             api_key=config.openrouter_api_key,
-            base_url="https://openrouter.ai/api/v1",
+            http_referer="https://github.com/crestalnetwork/intentkit",
+            x_open_router_title="IntentKit",
+            x_open_router_categories="cloud-agent",
+            timeout_ms=120_000,
         )
-        response = await client.images.generate(
-            model="bytedance-seed/seedream-4.5",
-            prompt=prompt,
-            size="1024x1024",
-            n=1,
+        response = await client.chat.send_async(
+            model=OPENROUTER_IMAGE_MODEL,
+            modalities=["image"],
+            messages=[{"role": "user", "content": prompt}],
         )
-        if response.data and response.data[0].b64_json:
-            return base64.b64decode(response.data[0].b64_json)
-        if response.data and response.data[0].url:
-            return await _download_image(response.data[0].url)
+        url = _extract_openrouter_image_url(response)
+        if not url:
+            logger.error("OpenRouter image generation returned no image url")
+            return None
+        if url.startswith("data:"):
+            return base64.b64decode(url.split(",", 1)[1])
+        return await _download_image(url)
     except Exception as e:
         logger.error("OpenRouter image generation failed: %s", e)
     return None
 
 
+def _extract_openrouter_image_url(response: Any) -> str | None:
+    """Pull the first image URL from an OpenRouter chat-completions response.
+
+    Different image models put the result in different places: most use
+    ``message.images[0].image_url.url``, a few return it as an ``image_url``
+    content part. Check both so avatar and skill callers stay consistent.
+    """
+    try:
+        message = response.choices[0].message
+    except (AttributeError, IndexError):
+        return None
+
+    images = getattr(message, "images", None) or []
+    if images:
+        url = getattr(getattr(images[0], "image_url", None), "url", None)
+        if url:
+            return url
+
+    content = getattr(message, "content", None)
+    if isinstance(content, list):
+        for part in content:
+            part_type = getattr(part, "type", None) or (
+                part.get("type") if isinstance(part, dict) else None
+            )
+            if part_type != "image_url":
+                continue
+            image_url = getattr(part, "image_url", None) or (
+                part.get("image_url") if isinstance(part, dict) else None
+            )
+            url = getattr(image_url, "url", None) or (
+                image_url.get("url") if isinstance(image_url, dict) else None
+            )
+            if url:
+                return url
+    return None
+
+
 async def generate_image_google(prompt: str) -> bytes | None:
     """Generate image using Google Gemini gemini-3.1-flash-image-preview."""
     try:

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/core/engine.py

@@ -378,6 +378,15 @@ async def _handle_model_chunk(
                 user_id=user_message.user_id,
             )
             logger.info("[%s] expense message: %s", user_message.agent_id, amount)
+            # Reconciliation: log OpenRouter-reported cost alongside our
+            # token-based calculation so discrepancies can be audited.
+            or_cost = (getattr(msg, "response_metadata", None) or {}).get("cost")
+            if or_cost is not None:
+                logger.info(
+                    "[%s] openrouter reported cost: %s",
+                    user_message.agent_id,
+                    or_cost,
+                )
             chat_message_create.credit_event_id = credit_event.id
             chat_message_create.credit_cost = credit_event.total_amount
             chat_message = await chat_message_create.save_in_session(session)
@@ -651,7 +660,8 @@ async def stream_agent_raw(
 
     # Determine payer team (needed for credit event recording regardless of payment_enabled)
     # Normal user conversations: user's team pays
-    # Platform channels (Telegram/Discord/Twitter/API/X402): agent's team pays
+    # Platform channels (Telegram/Discord/Twitter/API/X402) and autonomous triggers:
+    # agent's team pays
     payer = message.team_id
     if user_message.author_type in [
         AuthorType.TELEGRAM,
@@ -659,6 +669,7 @@ async def stream_agent_raw(
         AuthorType.TWITTER,
         AuthorType.API,
         AuthorType.X402,
+        AuthorType.TRIGGER,
     ]:
         payer = agent.team_id
 

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/core/team/membership.py

@@ -7,6 +7,8 @@ import re
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING
 
+from sqlalchemy import or_, update
+
 from intentkit.config.db import get_session
 from intentkit.config.redis import get_redis
 from intentkit.models.team import (
@@ -137,7 +139,12 @@ async def generate_team_avatar(team_id: str, team_name: str) -> str | None:
 
 
 async def create_team(team_id: str, name: str, creator_user_id: str) -> Team:
-    """Create a new team with avatar generation.
+    """Create a new team without avatar.
+
+    Avatar generation is deferred to a background task triggered by the
+    caller (see `backfill_team_avatar`), since generating a team picture
+    involves slow LLM + image-gen + S3 I/O that should not block the
+    creation response or widen the window for concurrent-create races.
 
     Raises:
         ValueError: If team ID format is invalid or already taken.
@@ -146,23 +153,58 @@ async def create_team(team_id: str, name: str, creator_user_id: str) -> Team:
     if not validation["valid"]:
         raise ValueError(str(validation["reason"]))
 
-    # Generate avatar (failure does not block creation)
-    avatar: str | None = None
-    try:
-        avatar = await generate_team_avatar(team_id, name)
-    except Exception as e:
-        logger.warning("Avatar generation failed for team %s: %s", team_id, e)
-
     team_create = TeamCreate(
         id=team_id,
         name=name,
-        avatar=avatar,
+        avatar=None,
         default_channel=None,
         default_channel_chat_id=None,
     )
     return await team_create.save(creator_user_id)
 
 
+async def backfill_team_avatar(team_id: str) -> None:
+    """Generate an avatar for a team and write it back if still empty.
+
+    Intended to be scheduled as a background task after team creation.
+    No-ops (and swallows all errors) if the team is gone, already has an
+    avatar, or the generation/upload fails.
+    """
+    async with get_session() as db:
+        team_row = await db.get(TeamTable, team_id)
+        if not team_row or team_row.avatar:
+            return
+        team_name = team_row.name
+
+    try:
+        avatar_path = await generate_team_avatar(team_id, team_name)
+    except Exception as e:
+        logger.warning("Team avatar backfill generate failed for %s: %s", team_id, e)
+        return
+    if not avatar_path:
+        return
+
+    try:
+        async with get_session() as db:
+            # Match both NULL and empty-string so a prior PATCH that cleared
+            # the column to "" still gets backfilled; the scheduling site
+            # treats empty string as missing, and the write must agree.
+            await db.execute(
+                update(TeamTable)
+                .where(
+                    TeamTable.id == team_id,
+                    or_(TeamTable.avatar.is_(None), TeamTable.avatar == ""),
+                )
+                .values(avatar=avatar_path)
+            )
+            await db.commit()
+    except Exception as e:
+        logger.warning("Team avatar backfill write failed for %s: %s", team_id, e)
+        return
+
+    await _invalidate_team_cache(team_id)
+
+
 async def get_team(team_id: str) -> Team | None:
     """Get a team by ID, with Redis caching (TTL 3600s)."""
     redis = get_redis()
@@ -199,8 +241,6 @@ async def update_team(
     if name is None and avatar is None:
         raise ValueError("No updates provided")
 
-    from sqlalchemy import update
-
     async with get_session() as db:
         values: dict[str, str] = {}
         if name is not None:
@@ -214,12 +254,7 @@ async def update_team(
             raise ValueError(f"Team {team_id} not found")
         await db.commit()
 
-    # Invalidate cache
-    try:
-        redis = get_redis()
-        await redis.delete(f"{_CACHE_TEAM_PREFIX}{team_id}")
-    except Exception as e:
-        logger.warning("Failed to invalidate team cache for %s: %s", team_id, e)
+    await _invalidate_team_cache(team_id)
 
     team = await Team.get(team_id)
     if not team:
@@ -384,6 +419,15 @@ async def _invalidate_role_cache(team_id: str, user_id: str) -> None:
         )
 
 
+async def _invalidate_team_cache(team_id: str) -> None:
+    """Delete cached team entry from Redis."""
+    try:
+        redis = get_redis()
+        await redis.delete(f"{_CACHE_TEAM_PREFIX}{team_id}")
+    except Exception as e:
+        logger.warning("Failed to invalidate team cache for %s: %s", team_id, e)
+
+
 async def change_member_role(team_id: str, user_id: str, new_role: TeamRole) -> None:
     """Change a team member's role.
 

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/models/llm.py

@@ -834,6 +834,11 @@ class OpenRouterLLM(LLMModel):
             "api_key": config.openrouter_api_key,
             "timeout": info.timeout * 1000,
             "max_retries": 3,
+            # Attribution headers so OpenRouter dashboard credits IntentKit
+            # instead of the LangChain defaults baked into langchain-openrouter.
+            "app_url": "https://github.com/crestalnetwork/intentkit",
+            "app_title": "IntentKit",
+            "app_categories": ["cloud-agent"],
         }
 
         # Add optional parameters based on model support
@@ -855,48 +860,44 @@ class OpenRouterLLM(LLMModel):
         return _create_openrouter_with_server_tools(**kwargs)
 
 
-_openrouter_sdk_patched = False
+_openrouter_usage_cost_fields_injected = False
 
 
-def _patch_openrouter_sdk() -> None:
-    """Patch the OpenRouter SDK to accept server tools.
+def _inject_cost_fields_into_chat_usage() -> None:
+    """Add ``cost`` / ``cost_details`` to the SDK's ``ChatUsage`` schema.
 
-    The SDK's ``ToolDefinitionJSON`` model requires ``type="function"`` and
-    a mandatory ``function`` field. OpenRouter server tools like
-    ``openrouter:web_search`` use different types and have no ``function``
-    field. This patch broadens ``ToolDefinitionJSON`` to accept any ``type``
-    string and makes ``function`` optional, so server-tool dicts pass through
-    the SDK's validation and are serialised as-is.
+    OpenRouter's ``/chat/completions`` response includes ``cost`` inside the
+    ``usage`` object, but ``openrouter`` SDK's generated ``ChatUsage`` model
+    (v0.9.1) does not declare those fields, so Pydantic validation drops them
+    and ``langchain-openrouter`` never surfaces them in ``response_metadata``.
+
+    Injecting the fields lets cost round-trip without a fork. Remove this
+    helper once the SDK adds the fields natively.
     """
-    global _openrouter_sdk_patched  # noqa: PLW0603
-    if _openrouter_sdk_patched:
+    global _openrouter_usage_cost_fields_injected  # noqa: PLW0603
+    if _openrouter_usage_cost_fields_injected:
         return
     try:
-        from openrouter.components import (
-            ToolDefinitionJSON,  # type: ignore[import-untyped]
-        )
+        from openrouter.components import ChatUsage  # type: ignore[import-untyped]
+        from pydantic.fields import FieldInfo
 
-        tool_model: Any = ToolDefinitionJSON
-        type_field = tool_model.model_fields.get("type")
-        func_field = tool_model.model_fields.get("function")
-        if type_field is None or func_field is None:
-            logger.warning(
-                "OpenRouter SDK ToolDefinitionJSON schema changed — "
-                "server tools patch skipped; update the integration"
-            )
+        if "cost" in ChatUsage.model_fields:
+            _openrouter_usage_cost_fields_injected = True
             return
-        # Broaden type from Literal["function"] to str
-        type_field.annotation = str
-        tool_model.__annotations__["type"] = str
-        # Make function optional (server tools don't have it)
-        orig = func_field.annotation
-        func_field.annotation = orig | None
-        func_field.default = None
-        tool_model.__annotations__["function"] = orig | None
-        tool_model.model_rebuild(force=True)
-        _openrouter_sdk_patched = True
+        cost_type: Any = float | None
+        cost_details_type: Any = dict[str, Any] | None
+        ChatUsage.__annotations__["cost"] = cost_type
+        ChatUsage.__annotations__["cost_details"] = cost_details_type
+        ChatUsage.model_fields["cost"] = FieldInfo(annotation=cost_type, default=None)
+        ChatUsage.model_fields["cost_details"] = FieldInfo(
+            annotation=cost_details_type, default=None
+        )
+        ChatUsage.model_rebuild(force=True)
+        _openrouter_usage_cost_fields_injected = True
     except Exception:
-        logger.warning("Failed to patch OpenRouter SDK for server tools", exc_info=True)
+        logger.warning(
+            "Failed to inject cost fields into OpenRouter ChatUsage", exc_info=True
+        )
 
 
 def _create_openrouter_with_server_tools(**kwargs: Any) -> BaseChatModel:
@@ -904,17 +905,18 @@ def _create_openrouter_with_server_tools(**kwargs: Any) -> BaseChatModel:
 
     OpenRouter server tools (e.g. ``{"type": "openrouter:web_search"}``) are
     not recognised by ``convert_to_openai_tool`` used inside the upstream
-    ``ChatOpenRouter.bind_tools``.  This subclass overrides ``bind_tools``
-    to pull server-tool dicts out, delegate the rest to the parent, and
-    re-inject the server tools into the bound kwargs so they are sent as-is
-    in the API request.
-
-    Additionally, the OpenRouter Python SDK's request model is patched once to
-    accept non-function tool types in the request body.
+    ``ChatOpenRouter.bind_tools``. This subclass overrides ``bind_tools`` to
+    pull server-tool dicts out, delegate the rest to the parent, and re-inject
+    the server tools into the bound kwargs so they are sent as-is in the API
+    request.
+
+    The underlying ``openrouter`` SDK (>=0.8.0) exposes ``ChatFunctionTool`` as
+    a discriminated union that natively accepts the ``openrouter:`` server-tool
+    types we use, so no SDK-level patch is required for tool types.
     """
     from langchain_openrouter import ChatOpenRouter
 
-    _patch_openrouter_sdk()
+    _inject_cost_fields_into_chat_usage()
 
     class _WithServerTools(ChatOpenRouter):
         @override

{intentkit-0.17.43 → intentkit-0.17.45}/intentkit/models/team.py

@@ -18,6 +18,7 @@ from pydantic import (
 )
 from sqlalchemy import DateTime, Index, Integer, String, func, select
 from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Mapped, mapped_column
 
 from intentkit.config.base import Base
@@ -326,7 +327,13 @@ class TeamCreate(BaseModel):
             )
             db.add(member_record)
 
-            await db.commit()
+            try:
+                await db.commit()
+            except IntegrityError as e:
+                # Concurrent request with the same team_id committed first; map
+                # to the same validation error so the endpoint returns 400 instead
+                # of leaking a 500.
+                raise ValueError("Team ID is already taken") from e
             await db.refresh(team_record)
             return Team.model_validate(team_record)