agentkit-sdk-python 0.7.3__tar.gz → 0.7.4__tar.gz

{agentkit_sdk_python-0.7.3/agentkit_sdk_python.egg-info → agentkit_sdk_python-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.7.3
+Version: 0.7.4
 Summary: Python SDK for transforming any AI agent into a production-ready application. Framework-agnostic primitives for runtime, memory, authentication, and tools with volcengine-managed infrastructure.
 Author-email: Xiangrui Cheng <innsdcc@gmail.com>, Yumeng Bao <baoyumeng.123@gmail.com>, Yaozheng Fang <fangyozheng@gmail.com>, Guodong Li <cu.eric.lee@gmail.com>
 License:                                  Apache License
@@ -244,6 +244,13 @@ Requires-Dist: pyreadline3; sys_platform == "win32"
 Provides-Extra: extensions
 Provides-Extra: toolkit
 Provides-Extra: dev
+Provides-Extra: langchain
+Requires-Dist: langchain; extra == "langchain"
+Provides-Extra: langgraph
+Requires-Dist: langgraph; extra == "langgraph"
+Provides-Extra: frameworks
+Requires-Dist: langchain; extra == "frameworks"
+Requires-Dist: langgraph; extra == "frameworks"
 Dynamic: license-file
 
 <div align="center">

agentkit_sdk_python-0.7.4/agentkit/frameworks/__init__.py

@@ -0,0 +1,29 @@
+"""Framework adapters for running third-party agents in AgentKit apps."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentkit.frameworks._common import (
+    FrameworkBridgeError,
+    UnsupportedFrameworkAgentError,
+)
+
+__all__ = [
+    "FrameworkBridgeError",
+    "LangChainAgentkitBridge",
+    "LangGraphAgentkitBridge",
+    "UnsupportedFrameworkAgentError",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "LangChainAgentkitBridge":
+        from agentkit.frameworks.langchain import LangChainAgentkitBridge
+
+        return LangChainAgentkitBridge
+    if name == "LangGraphAgentkitBridge":
+        from agentkit.frameworks.langgraph import LangGraphAgentkitBridge
+
+        return LangGraphAgentkitBridge
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

agentkit_sdk_python-0.7.4/agentkit/frameworks/_common.py

@@ -0,0 +1,136 @@
+"""Shared helpers for framework-to-ADK adapters."""
+
+from __future__ import annotations
+
+import inspect
+import json
+from typing import Any
+
+from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events import Event
+from google.genai import types
+
+
+class FrameworkBridgeError(RuntimeError):
+    """Base error raised by AgentKit framework adapters."""
+
+
+class UnsupportedFrameworkAgentError(FrameworkBridgeError):
+    """Raised when an entry object does not expose a supported agent protocol."""
+
+
+def user_text(ctx: InvocationContext) -> str:
+    content = ctx.user_content
+    if content is None or not content.parts:
+        return ""
+    texts: list[str] = []
+    for part in content.parts:
+        text = getattr(part, "text", None)
+        if text:
+            texts.append(text)
+    return "\n".join(texts)
+
+
+def json_text(value: Any) -> str:
+    try:
+        return json.dumps(value, ensure_ascii=False, default=str)
+    except Exception:
+        return str(value)
+
+
+def content_to_text(content: Any) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, dict):
+        for key in ("text", "content", "output", "answer"):
+            if key in content:
+                text = content_to_text(content[key])
+                if text:
+                    return text
+        return json_text(content)
+    if isinstance(content, list):
+        return "".join(content_to_text(item) for item in content)
+    text = getattr(content, "text", None)
+    if isinstance(text, str):
+        return text
+    return str(content)
+
+
+def chunk_to_text(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    content = getattr(value, "content", None)
+    if content is not None:
+        return content_to_text(content)
+    text = getattr(value, "text", None)
+    if isinstance(text, str):
+        return text
+    if isinstance(value, dict):
+        for key in ("output", "answer", "text", "content"):
+            if key in value:
+                text = chunk_to_text(value[key])
+                if text:
+                    return text
+        messages = value.get("messages")
+        if isinstance(messages, (list, tuple)) and messages:
+            return chunk_to_text(messages[-1])
+        for nested in value.values():
+            text = chunk_to_text(nested)
+            if text:
+                return text
+        return json_text(value)
+    if isinstance(value, (list, tuple)):
+        for item in reversed(value):
+            text = chunk_to_text(item)
+            if text:
+                return text
+        return ""
+    return str(value)
+
+
+def adk_event(
+    ctx: InvocationContext,
+    author: str,
+    text: str,
+    *,
+    partial: bool,
+) -> Event:
+    return Event(
+        invocation_id=ctx.invocation_id,
+        author=author,
+        branch=ctx.branch,
+        partial=partial,
+        content=types.Content(role="model", parts=[types.Part(text=text)]),
+    )
+
+
+async def maybe_await(value: Any) -> Any:
+    if inspect.isawaitable(value):
+        return await value
+    return value
+
+
+def is_input_shape_error(exc: Exception) -> bool:
+    message = str(exc)
+    name = exc.__class__.__name__
+    return (
+        name == "InvalidUpdateError"
+        or "Invalid input type" in message
+        or "Must be a PromptValue, str, or list of BaseMessages" in message
+        or "Expected dict" in message
+        or "string indices must be integers" in message
+        or "'str' object is not subscriptable" in message
+        or "Input to ChatPromptTemplate is missing variables" in message
+    )
+
+
+def chunk_delta(accumulated: str, text: str) -> str:
+    if not accumulated:
+        return text
+    if text.startswith(accumulated):
+        return text[len(accumulated) :]
+    return text

agentkit_sdk_python-0.7.4/agentkit/frameworks/langchain.py

@@ -0,0 +1,170 @@
+"""LangChain adapter for AgentKit apps."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from google.adk.agents.base_agent import BaseAgent
+from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events import Event
+from pydantic import PrivateAttr
+
+from agentkit.frameworks._common import (
+    UnsupportedFrameworkAgentError,
+    adk_event,
+    chunk_delta,
+    chunk_to_text,
+    is_input_shape_error,
+    maybe_await,
+    user_text,
+)
+
+
+try:
+    from langchain_core.messages import HumanMessage
+except ImportError:  # pragma: no cover - depends on optional packages.
+    HumanMessage = None  # type: ignore[assignment]
+
+
+class LangChainAgentkitBridge(BaseAgent):
+    """Adapt a LangChain Runnable or callable to AgentKit's ADK runtime boundary."""
+
+    _runnable: Any = PrivateAttr()
+    _input_key: str = PrivateAttr(default="input")
+
+    def __init__(
+        self,
+        runnable: Any,
+        *,
+        name: str = "langchain_agent",
+        description: str = "LangChain agent adapted for AgentKit runtime",
+        input_key: str = "input",
+    ) -> None:
+        super().__init__(name=name, description=description)
+        self._runnable = runnable
+        self._input_key = input_key
+
+    def _input_candidates(self, payload: dict[str, Any], text_input: str) -> list[Any]:
+        candidates: list[Any] = [payload, text_input]
+        if HumanMessage is not None:
+            message = HumanMessage(content=text_input)
+            candidates.extend(([message], {"messages": [message]}))
+        return candidates
+
+    async def _call_once(self, payload: dict[str, Any], text_input: str) -> Any:
+        candidates = self._input_candidates(payload, text_input)
+        ainvoke = getattr(self._runnable, "ainvoke", None)
+        if callable(ainvoke):
+            last_error: Exception | None = None
+            for candidate in candidates:
+                try:
+                    return await ainvoke(candidate)
+                except Exception as exc:
+                    if not is_input_shape_error(exc):
+                        raise
+                    last_error = exc
+            if last_error is not None:
+                raise last_error
+
+        invoke = getattr(self._runnable, "invoke", None)
+        if callable(invoke):
+            last_error = None
+            for candidate in candidates:
+                try:
+                    return invoke(candidate)
+                except Exception as exc:
+                    if not is_input_shape_error(exc):
+                        raise
+                    last_error = exc
+            if last_error is not None:
+                raise last_error
+
+        if callable(self._runnable):
+            last_error = None
+            for candidate in candidates:
+                try:
+                    return await maybe_await(self._runnable(candidate))
+                except Exception as exc:
+                    if not is_input_shape_error(exc):
+                        raise
+                    last_error = exc
+            if last_error is not None:
+                raise last_error
+
+        raise UnsupportedFrameworkAgentError(
+            "LangChain entry must be a Runnable-like object exposing "
+            "astream, stream, ainvoke, or invoke, or a callable that accepts the user input."
+        )
+
+    async def _stream_chunks(self, payload: dict[str, Any], text_input: str):
+        astream = getattr(self._runnable, "astream", None)
+        if callable(astream):
+            last_error: Exception | None = None
+            for candidate in self._input_candidates(payload, text_input):
+                emitted = False
+                try:
+                    async for chunk in astream(candidate):
+                        emitted = True
+                        yield chunk
+                    return
+                except Exception as exc:
+                    if emitted:
+                        raise
+                    if not is_input_shape_error(exc):
+                        raise
+                    last_error = exc
+            if last_error is not None:
+                raise last_error
+            return
+
+        stream = getattr(self._runnable, "stream", None)
+        if callable(stream):
+            last_error = None
+            for candidate in self._input_candidates(payload, text_input):
+                emitted = False
+                try:
+                    for chunk in stream(candidate):
+                        emitted = True
+                        yield chunk
+                    return
+                except Exception as exc:
+                    if emitted:
+                        raise
+                    if not is_input_shape_error(exc):
+                        raise
+                    last_error = exc
+            if last_error is not None:
+                raise last_error
+
+    async def _run_async_impl(
+        self,
+        ctx: InvocationContext,
+    ) -> AsyncGenerator[Event, None]:
+        text_input = user_text(ctx)
+        payload = {self._input_key: text_input}
+        accumulated_text = ""
+        has_output = False
+        last_text = ""
+        streamed = False
+
+        async for chunk in self._stream_chunks(payload, text_input):
+            streamed = True
+            text = chunk_to_text(chunk)
+            if not text:
+                continue
+            delta = chunk_delta(accumulated_text, text)
+            if not delta:
+                continue
+            accumulated_text += delta
+            has_output = True
+            last_text = accumulated_text
+            yield adk_event(ctx, self.name, delta, partial=True)
+
+        if not streamed:
+            result = await self._call_once(payload, text_input)
+            last_text = chunk_to_text(result)
+
+        final_text = accumulated_text if has_output else last_text
+        if final_text:
+            yield adk_event(ctx, self.name, final_text, partial=False)