intentkit 1.2.4__tar.gz → 1.2.6__tar.gz

{intentkit-1.2.4 → intentkit-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 1.2.4
+Version: 1.2.6
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit

{intentkit-1.2.4 → intentkit-1.2.6}/intentkit/__init__.py

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

{intentkit-1.2.4 → intentkit-1.2.6}/intentkit/core/engine.py

@@ -13,13 +13,14 @@ The module uses a global cache to store initialized agents for better performanc
 # pyright: reportImportCycles=false
 
 import asyncio
+import base64
 import logging
 import mimetypes
 import re
 import textwrap
 import time
 import traceback
-from typing import Any
+from typing import Any, NamedTuple
 
 import httpcore
 import httpx
@@ -73,11 +74,10 @@ _FORWARDABLE_TYPES = frozenset(
 )
 
 # Maps each forwardable attachment type to (model capability flag,
-# unsupported-error system message). Image keeps the legacy OpenAI-style
-# `image_url` block, accepted by every LangChain provider adapter we use.
-# The other three emit LangChain v0.3 standard multimodal blocks
-# `{"type": ..., "url": ...}` — currently only langchain-google-genai 3.2+
-# converts these to provider Parts. See _MEDIA_PROVIDER_SUPPORT.
+# unsupported-error system message). The CSV's `supports_<type>_input`
+# flags are the source of truth; if a model advertises a capability that
+# its provider's LangChain adapter cannot actually deliver, the call
+# surfaces an internal error and the operator should correct the CSV.
 _MEDIA_INPUT_SPECS: list[tuple[ChatMessageAttachmentType, str, SystemMessageType]] = [
     (
         ChatMessageAttachmentType.IMAGE,
@@ -101,30 +101,9 @@ _MEDIA_INPUT_SPECS: list[tuple[ChatMessageAttachmentType, str, SystemMessageType
     ),
 ]
 
-# Providers whose LangChain adapter accepts our content-block shape for each
-# media type. Non-image types use the v0.3 standard block which currently
-# only langchain-google-genai handles; OpenAI/Anthropic require base64 data
-# blocks (`input_audio` / `document`) and are not yet implemented. A model
-# advertising capability=true on an unsupported provider is gated the same
-# way as one that doesn't advertise the capability — better than emitting
-# blocks that crash mid-stream with AGENT_INTERNAL_ERROR.
-_MEDIA_PROVIDER_SUPPORT: dict[ChatMessageAttachmentType, set[LLMProvider] | None] = {
-    ChatMessageAttachmentType.IMAGE: None,  # all providers
-    ChatMessageAttachmentType.AUDIO: {LLMProvider.GOOGLE},
-    ChatMessageAttachmentType.VIDEO: {LLMProvider.GOOGLE},
-    ChatMessageAttachmentType.FILE: {LLMProvider.GOOGLE},
-}
-
-
-def _model_can_deliver_media(
-    atype: ChatMessageAttachmentType, provider: LLMProvider
-) -> bool:
-    allowed = _MEDIA_PROVIDER_SUPPORT.get(atype)
-    return allowed is None or provider in allowed
-
-
-# Per-type fallback when the URL extension is unknown. Gemini rejects
-# inlineData with an empty mimeType, so we need to always supply something.
+# Per-type fallback when both the HTTP Content-Type and the URL extension
+# fail to yield a usable mime. Gemini's inlineData and OpenAI's input_audio
+# both reject empty mime/format values, so we always need a concrete value.
 _MEDIA_DEFAULT_MIME: dict[ChatMessageAttachmentType, str] = {
     ChatMessageAttachmentType.IMAGE: "image/jpeg",
     ChatMessageAttachmentType.AUDIO: "audio/mpeg",
@@ -132,30 +111,70 @@ _MEDIA_DEFAULT_MIME: dict[ChatMessageAttachmentType, str] = {
     ChatMessageAttachmentType.FILE: "application/octet-stream",
 }
 
+# Cap a single fetch — the upload to S3 already bounds attachment size
+# upstream. 30 s is well above any expected voice/image/file fetch.
+_MEDIA_FETCH_TIMEOUT = 30.0
+
 
-def _guess_media_mime_type(atype: ChatMessageAttachmentType, url: str) -> str:
-    # Strip query string before guessing — `?signed=...` etc. would otherwise
-    # eat the extension.
-    path_only = url.split("?", 1)[0].split("#", 1)[0]
-    guessed, _ = mimetypes.guess_type(path_only)
-    if guessed:
-        return guessed
-    return _MEDIA_DEFAULT_MIME[atype]
+class _FetchedMedia(NamedTuple):
+    data: bytes
+    mime_type: str
 
 
-def _build_media_content_block(
-    atype: ChatMessageAttachmentType, url: str
+async def _fetch_media_bytes(
+    url: str, atype: ChatMessageAttachmentType
+) -> _FetchedMedia:
+    """Fetch a media URL and resolve its mime type.
+
+    Order of preference for mime: HTTP Content-Type response header
+    (explicit, set by S3 at upload time) → URL path extension via
+    `mimetypes` → per-type default.
+    """
+    async with httpx.AsyncClient(
+        timeout=_MEDIA_FETCH_TIMEOUT, follow_redirects=True
+    ) as client:
+        resp = await client.get(url)
+        resp.raise_for_status()
+
+    raw_ct = resp.headers.get("content-type", "")
+    mime = raw_ct.split(";", 1)[0].strip().lower()
+    if not mime or mime == "application/octet-stream":
+        path_only = url.split("?", 1)[0].split("#", 1)[0]
+        guessed, _ = mimetypes.guess_type(path_only)
+        if guessed:
+            mime = guessed
+    if not mime:
+        mime = _MEDIA_DEFAULT_MIME[atype]
+    return _FetchedMedia(data=resp.content, mime_type=mime)
+
+
+def _build_image_url_block(url: str) -> dict[str, Any]:
+    """OpenAI Chat Completions image block — accepted by every adapter."""
+    return {"type": "image_url", "image_url": {"url": url}}
+
+
+def _build_v1_data_block(
+    atype: ChatMessageAttachmentType, fetched: _FetchedMedia
 ) -> dict[str, Any]:
-    if atype == ChatMessageAttachmentType.IMAGE:
-        return {"type": "image_url", "image_url": {"url": url}}
-    # LangChain v0.3 standard multimodal block. `source_type` disambiguates
-    # url vs base64; `mime_type` is required because langchain-google-genai
-    # forwards inlineData to Gemini, which rejects an empty mimeType.
+    """LangChain v1 standard multimodal data block with embedded base64.
+
+    This shape is recognized by every provider adapter we use:
+      - langchain-google-genai decodes base64 and forwards as Gemini
+        ``inlineData(data, mimeType)``
+      - langchain-openai converts to ``input_audio`` / ``file`` Chat
+        Completions blocks (audio + PDFs only)
+      - langchain-anthropic converts ``file`` to ``document`` blocks
+        (PDFs only — Anthropic has no audio/video input)
+      - langchain-openrouter / langchain-xai inherit OpenAI conversion
+
+    Fetching ourselves and embedding the bytes avoids LangChain's URL fetch
+    + mime guessing path, which has produced empty-mimeType errors against
+    Gemini in the field.
+    """
     return {
         "type": atype.value,
-        "source_type": "url",
-        "url": url,
-        "mime_type": _guess_media_mime_type(atype, url),
+        "base64": base64.b64encode(fetched.data).decode("ascii"),
+        "mime_type": fetched.mime_type,
     }
 
 
@@ -914,9 +933,7 @@ async def stream_agent_raw(
     for atype, capability, error_type in _MEDIA_INPUT_SPECS:
         if not media_urls_by_type[atype]:
             continue
-        if not getattr(model, capability) or not _model_can_deliver_media(
-            atype, model.provider
-        ):
+        if not getattr(model, capability):
             yield await _create_system_error_response(
                 error_type,
                 user_message,
@@ -956,6 +973,13 @@ async def stream_agent_raw(
     messages = [
         HumanMessage(content=input_message),
     ]
+    # Image URLs ride straight through as `image_url` blocks; the LangChain
+    # adapter handles the fetch. Audio/video/file get fetched here so we
+    # can hand Gemini a `media` block with raw bytes + an explicit
+    # mime_type, avoiding the empty-mimeType failure mode that the URL-only
+    # data block path has produced in production.
+    fetch_tasks: list = []
+    fetch_meta: list[ChatMessageAttachmentType] = []
     for atype, _, _ in _MEDIA_INPUT_SPECS:
         urls = media_urls_by_type[atype]
         if not urls:
@@ -968,11 +992,33 @@ async def stream_agent_raw(
             user_message.chat_id,
             urls,
         )
+        if atype == ChatMessageAttachmentType.IMAGE:
+            messages.extend(
+                HumanMessage(content=[_build_image_url_block(url)]) for url in urls
+            )
+            continue
+        for url in urls:
+            fetch_tasks.append(_fetch_media_bytes(url, atype))
+            fetch_meta.append(atype)
+
+    if fetch_tasks:
+        try:
+            fetched_media = await asyncio.gather(*fetch_tasks)
+        except Exception:
+            logger.exception(
+                "Failed to fetch media attachments for agent=%s chat=%s",
+                user_message.agent_id,
+                user_message.chat_id,
+            )
+            yield await _create_system_error_response(
+                SystemMessageType.AGENT_INTERNAL_ERROR,
+                user_message,
+                time.perf_counter() - start,
+            )
+            return
         messages.extend(
-            [
-                HumanMessage(content=[_build_media_content_block(atype, url)])
-                for url in urls
-            ]
+            HumanMessage(content=[_build_v1_data_block(atype, fetched)])
+            for atype, fetched in zip(fetch_meta, fetched_media, strict=True)
         )
 
     # stream config

{intentkit-1.2.4 → intentkit-1.2.6}/pyproject.toml

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