agentkit-sdk-python 0.7.3__py3-none-any.whl → 0.7.4__py3-none-any.whl

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/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/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)

agentkit/frameworks/langgraph.py

@@ -0,0 +1,349 @@
+"""LangGraph adapter for AgentKit apps."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+import inspect
+import json
+from typing import Any
+
+try:
+    from langchain_core.messages import HumanMessage
+except ImportError as exc:  # pragma: no cover - depends on optional packages.
+    raise ImportError(
+        "LangGraph bridge requires langgraph/langchain-core. "
+        "Install langgraph or use the requirements generated by agentkit migrate."
+    ) from exc
+
+from google.adk.agents.base_agent import BaseAgent
+from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events import Event, EventActions
+from google.genai import types
+from pydantic import PrivateAttr
+
+try:
+    from langgraph.types import Command
+except ImportError:  # pragma: no cover - older optional langgraph versions.
+    Command = None  # type: ignore[assignment]
+
+from agentkit.frameworks._common import (
+    UnsupportedFrameworkAgentError,
+    adk_event,
+    chunk_delta,
+    chunk_to_text,
+    user_text,
+)
+
+
+LANGGRAPH_PENDING_INTERRUPT_STATE_KEY = "agentkit:langgraph:pending_interrupt"
+
+
+def _method_kwargs(method: Any, kwargs: dict[str, Any]) -> dict[str, Any]:
+    try:
+        signature = inspect.signature(method)
+    except (TypeError, ValueError):
+        return kwargs
+
+    parameters = signature.parameters
+    accepts_kwargs = any(param.kind == inspect.Parameter.VAR_KEYWORD for param in parameters.values())
+    return {key: value for key, value in kwargs.items() if accepts_kwargs or key in parameters}
+
+
+def _jsonable(value: Any) -> Any:
+    try:
+        json.dumps(value, ensure_ascii=False)
+        return value
+    except Exception:
+        return str(value)
+
+
+def _interrupt_payload(data: Any) -> Any | None:
+    if not isinstance(data, dict) or "__interrupt__" not in data:
+        return None
+    interrupts = data.get("__interrupt__")
+    if not isinstance(interrupts, (list, tuple)) or not interrupts:
+        return interrupts
+    values: list[dict[str, Any]] = []
+    for interrupt in interrupts:
+        values.append(
+            {
+                "id": getattr(interrupt, "id", None),
+                "value": _jsonable(getattr(interrupt, "value", interrupt)),
+            }
+        )
+    return values
+
+
+def _resume_value(text_input: str) -> Any:
+    stripped = text_input.strip()
+    if stripped.startswith(("{", "[")):
+        try:
+            return json.loads(stripped)
+        except json.JSONDecodeError:
+            return text_input
+    return text_input
+
+
+class LangGraphAgentkitBridge(BaseAgent):
+    """Adapt a compiled LangGraph graph to AgentKit's ADK runtime boundary."""
+
+    _graph: Any = PrivateAttr()
+    _input_key: str | None = PrivateAttr(default=None)
+
+    def __init__(
+        self,
+        graph: Any,
+        *,
+        name: str = "langgraph_agent",
+        description: str = "LangGraph agent adapted for AgentKit runtime",
+        input_key: str | None = None,
+    ) -> None:
+        super().__init__(name=name, description=description)
+        self._graph = graph
+        self._input_key = input_key
+
+    def _input_payload(self, text_input: str) -> dict[str, Any]:
+        if self._input_key:
+            return {self._input_key: text_input}
+        return {"messages": [HumanMessage(content=text_input)]}
+
+    def _graph_config(self, ctx: InvocationContext) -> dict[str, Any] | None:
+        session = getattr(ctx, "session", None)
+        session_id = getattr(session, "id", None)
+        if not session_id:
+            return None
+        return {"configurable": {"thread_id": session_id}}
+
+    def _pending_interrupt(self, ctx: InvocationContext) -> Any | None:
+        session = getattr(ctx, "session", None)
+        state = getattr(session, "state", None)
+        if not isinstance(state, dict):
+            return None
+        pending = state.get(LANGGRAPH_PENDING_INTERRUPT_STATE_KEY)
+        if not pending:
+            return None
+        if isinstance(pending, dict) and pending.get("agent") not in {None, self.name}:
+            return None
+        return pending
+
+    def _run_payload(self, ctx: InvocationContext) -> Any:
+        text_input = user_text(ctx)
+        if self._pending_interrupt(ctx) is None:
+            return self._input_payload(text_input)
+        if Command is None:
+            raise UnsupportedFrameworkAgentError(
+                "LangGraph HITL resume requires langgraph.types.Command. "
+                "Upgrade langgraph or start a new AgentKit session."
+            )
+        return Command(resume=_resume_value(text_input))
+
+    def _interrupt_state_delta(self, ctx: InvocationContext, config: dict[str, Any] | None, interrupt: Any) -> dict[str, Any]:
+        session = getattr(ctx, "session", None)
+        session_id = getattr(session, "id", None)
+        if not session_id:
+            return {}
+        return {
+            LANGGRAPH_PENDING_INTERRUPT_STATE_KEY: {
+                "agent": self.name,
+                "thread_id": config.get("configurable", {}).get("thread_id") if config else session_id,
+                "interrupts": interrupt,
+            }
+        }
+
+    def _final_event(self, ctx: InvocationContext, text: str, *, clear_pending_interrupt: bool) -> Event:
+        event_kwargs: dict[str, Any] = {}
+        if clear_pending_interrupt:
+            event_kwargs["actions"] = EventActions(state_delta={LANGGRAPH_PENDING_INTERRUPT_STATE_KEY: None})
+        return Event(
+            invocation_id=ctx.invocation_id,
+            author=self.name,
+            branch=ctx.branch,
+            partial=False,
+            content=types.Content(role="model", parts=[types.Part(text=text)]),
+            **event_kwargs,
+        )
+
+    def _clear_pending_interrupt_event(self, ctx: InvocationContext) -> Event:
+        return Event(
+            invocation_id=ctx.invocation_id,
+            author=self.name,
+            branch=ctx.branch,
+            actions=EventActions(state_delta={LANGGRAPH_PENDING_INTERRUPT_STATE_KEY: None}),
+        )
+
+    async def _call_once(self, payload: Any, config: dict[str, Any] | None) -> Any:
+        ainvoke = getattr(self._graph, "ainvoke", None)
+        if callable(ainvoke):
+            return await ainvoke(payload, **_method_kwargs(ainvoke, {"config": config}))
+
+        invoke = getattr(self._graph, "invoke", None)
+        if callable(invoke):
+            return invoke(payload, **_method_kwargs(invoke, {"config": config}))
+
+        raise UnsupportedFrameworkAgentError(
+            "LangGraph entry must be a compiled graph-like object exposing "
+            "astream, stream, ainvoke, or invoke."
+        )
+
+    def _sync_stream(self, payload: Any, config: dict[str, Any] | None):
+        stream_fn = getattr(self._graph, "stream", None)
+        if not callable(stream_fn):
+            return None
+        try:
+            return stream_fn(
+                payload,
+                **_method_kwargs(
+                    stream_fn,
+                    {
+                        "config": config,
+                        "stream_mode": ["messages", "updates"],
+                        "version": "v2",
+                    },
+                ),
+            )
+        except TypeError:
+            try:
+                return stream_fn(
+                    payload,
+                    **_method_kwargs(
+                        stream_fn,
+                        {
+                            "config": config,
+                            "stream_mode": ["messages", "updates"],
+                        },
+                    ),
+                )
+            except TypeError:
+                return stream_fn(payload, **_method_kwargs(stream_fn, {"config": config}))
+
+    async def _stream_graph(self, payload: Any, config: dict[str, Any] | None, *, prefer_sync: bool = False):
+        if prefer_sync:
+            stream = self._sync_stream(payload, config)
+            if stream is not None:
+                for item in stream:
+                    yield item
+                return
+
+        astream = getattr(self._graph, "astream", None)
+        if callable(astream):
+            try:
+                stream = astream(
+                    payload,
+                    **_method_kwargs(
+                        astream,
+                        {
+                            "config": config,
+                            "stream_mode": ["messages", "updates"],
+                            "version": "v2",
+                        },
+                    ),
+                )
+            except TypeError:
+                try:
+                    stream = astream(
+                        payload,
+                        **_method_kwargs(
+                            astream,
+                            {
+                                "config": config,
+                                "stream_mode": ["messages", "updates"],
+                            },
+                        ),
+                    )
+                except TypeError:
+                    stream = astream(payload, **_method_kwargs(astream, {"config": config}))
+            async for item in stream:
+                yield item
+            return
+
+        stream = self._sync_stream(payload, config)
+        if stream is not None:
+            for item in stream:
+                yield item
+
+    async def _run_async_impl(
+        self,
+        ctx: InvocationContext,
+    ) -> AsyncGenerator[Event, None]:
+        config = self._graph_config(ctx)
+        resume_pending = self._pending_interrupt(ctx) is not None
+        payload = self._run_payload(ctx)
+        accumulated_text = ""
+        has_output = False
+        last_update: Any = None
+        pending_update_text = ""
+        saw_messages = False
+        streamed = False
+
+        async for item in self._stream_graph(payload, config, prefer_sync=resume_pending):
+            streamed = True
+            mode = ""
+            data = item
+            if isinstance(item, tuple) and len(item) == 2 and isinstance(item[0], str):
+                mode, data = item
+            elif isinstance(item, dict) and isinstance(item.get("type"), str):
+                mode = item["type"]
+                data = item.get("data")
+
+            if mode == "messages":
+                message = data[0] if isinstance(data, tuple) and data else data
+                text = chunk_to_text(message)
+                if not text:
+                    continue
+                delta = chunk_delta(accumulated_text, text)
+                if not delta:
+                    continue
+                saw_messages = True
+                accumulated_text += delta
+                has_output = True
+                yield adk_event(ctx, self.name, delta, partial=True)
+                continue
+
+            if mode == "updates":
+                interrupt = _interrupt_payload(data)
+                if interrupt is not None:
+                    state_delta = self._interrupt_state_delta(ctx, config, interrupt)
+                    event_kwargs: dict[str, Any] = {}
+                    if state_delta:
+                        event_kwargs["actions"] = EventActions(state_delta=state_delta)
+                    yield Event(
+                        invocation_id=ctx.invocation_id,
+                        author=self.name,
+                        branch=ctx.branch,
+                        interrupted=True,
+                        error_code="LANGGRAPH_INTERRUPT",
+                        error_message="LangGraph execution interrupted and requires resume input.",
+                        custom_metadata={"langgraph_interrupt": interrupt},
+                        **event_kwargs,
+                    )
+                    return
+                last_update = data
+                if saw_messages:
+                    continue
+                text = chunk_to_text(data)
+                if text:
+                    pending_update_text = text
+                continue
+
+            text = chunk_to_text(data)
+            if text:
+                delta = chunk_delta(accumulated_text, text)
+                if delta:
+                    accumulated_text += delta
+                    has_output = True
+                    yield adk_event(ctx, self.name, delta, partial=True)
+
+        if streamed:
+            if saw_messages or has_output:
+                final_text = accumulated_text
+            else:
+                final_text = pending_update_text or chunk_to_text(last_update)
+                if final_text:
+                    yield adk_event(ctx, self.name, final_text, partial=True)
+        else:
+            final_text = chunk_to_text(await self._call_once(payload, config))
+
+        if final_text:
+            yield self._final_event(ctx, final_text, clear_pending_interrupt=resume_pending)
+        elif resume_pending:
+            yield self._clear_pending_interrupt_event(ctx)

agentkit/frameworks/serving/__init__.py

@@ -0,0 +1,6 @@
+"""Serving compatibility helpers for migrated framework agents."""
+
+from agentkit.frameworks.serving.fastapi_mount import mount_legacy_fastapi_app
+from agentkit.frameworks.serving.langserve import attach_langserve_compat_routes
+
+__all__ = ["attach_langserve_compat_routes", "mount_legacy_fastapi_app"]

agentkit/frameworks/serving/fastapi_mount.py

@@ -0,0 +1,65 @@
+"""Helpers for mounting an existing FastAPI app beside AgentKit routes."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from fastapi import FastAPI
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_prefix(prefix: str) -> str:
+    if not prefix:
+        raise ValueError("legacy FastAPI mount prefix must not be empty.")
+    if not prefix.startswith("/"):
+        raise ValueError("legacy FastAPI mount prefix must start with '/'.")
+    if prefix != "/" and prefix.endswith("/"):
+        return prefix.rstrip("/")
+    return prefix
+
+
+def mount_legacy_fastapi_app(
+    app: FastAPI,
+    legacy_app: Any,
+    *,
+    prefix: str = "/legacy",
+    allow_root: bool = False,
+) -> None:
+    """Mount a user-owned FastAPI app without rewriting its routes."""
+
+    normalized_prefix = _normalize_prefix(prefix)
+    if normalized_prefix == "/" and not allow_root:
+        raise ValueError(
+            "mounting a legacy FastAPI app at '/' can shadow AgentKit routes; "
+            "pass allow_root=True only when you intentionally want that behavior."
+        )
+    if not isinstance(legacy_app, FastAPI):
+        raise TypeError("legacy_app must be a fastapi.FastAPI instance.")
+
+    logger.info("Mounting legacy FastAPI app at %s", normalized_prefix)
+    app.mount(normalized_prefix, legacy_app)
+    _promote_mount(app, normalized_prefix)
+
+
+def _promote_mount(app: FastAPI, path: str) -> None:
+    routes = app.router.routes
+    route_index = next(
+        (
+            index
+            for index, route in enumerate(routes)
+            if getattr(route, "path", None) == ("" if path == "/" else path)
+        ),
+        None,
+    )
+    if route_index is None:
+        return
+
+    route = routes.pop(route_index)
+    insert_at = len(routes)
+    for index, existing in enumerate(routes):
+        if getattr(existing, "path", None) in {"", "/"}:
+            insert_at = index
+            break
+    routes.insert(insert_at, route)

agentkit/frameworks/serving/langserve.py

@@ -0,0 +1,502 @@
+"""LangServe-like HTTP compatibility routes for migrated LangChain agents."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import logging
+from collections.abc import AsyncGenerator
+from typing import Any
+from uuid import uuid4
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from agentkit.frameworks._common import (
+    UnsupportedFrameworkAgentError,
+    chunk_to_text,
+    is_input_shape_error,
+    maybe_await,
+)
+
+logger = logging.getLogger(__name__)
+
+try:
+    from langchain_core.messages import HumanMessage
+except ImportError:  # pragma: no cover - optional dependency.
+    HumanMessage = None  # type: ignore[assignment]
+
+
+def _normalize_prefix(prefix: str) -> str:
+    if prefix == "/":
+        return ""
+    if prefix and not prefix.startswith("/"):
+        raise ValueError("LangServe compatibility prefix must start with '/'.")
+    return prefix.rstrip("/")
+
+
+def _jsonable(value: Any) -> Any:
+    try:
+        return jsonable_encoder(value)
+    except Exception:
+        return json.loads(json.dumps(value, ensure_ascii=False, default=str))
+
+
+async def _request_json(request: Request) -> Any:
+    try:
+        return await request.json()
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail="Request body must be valid JSON.") from exc
+
+
+def _extract_input(payload: Any) -> Any:
+    if isinstance(payload, dict) and "input" in payload:
+        return payload["input"]
+    return payload
+
+
+def _request_options(payload: Any) -> tuple[Any, dict[str, Any]]:
+    if not isinstance(payload, dict):
+        return None, {}
+    config = payload.get("config")
+    kwargs = payload.get("kwargs")
+    return config, kwargs if isinstance(kwargs, dict) else {}
+
+
+def _input_candidates(value: Any, input_key: str) -> list[Any]:
+    candidates: list[Any] = []
+    if isinstance(value, dict):
+        candidates.append(value)
+    elif input_key != "input":
+        candidates.append({input_key: value})
+        candidates.append(value)
+    else:
+        candidates.append(value)
+        candidates.append({input_key: value})
+
+    if isinstance(value, str) and HumanMessage is not None:
+        message = HumanMessage(content=value)
+        candidates.extend(([message], {"messages": [message]}))
+
+    deduped: list[Any] = []
+    for candidate in candidates:
+        if not any(candidate == existing for existing in deduped):
+            deduped.append(candidate)
+    return deduped
+
+
+def _method_kwargs(method: Any, config: Any, extra_kwargs: dict[str, Any]) -> dict[str, Any]:
+    if config is None and not extra_kwargs:
+        return {}
+
+    try:
+        signature = inspect.signature(method)
+    except (TypeError, ValueError):
+        return {"config": config, **extra_kwargs} if config is not None else dict(extra_kwargs)
+
+    parameters = signature.parameters
+    accepts_kwargs = any(param.kind == inspect.Parameter.VAR_KEYWORD for param in parameters.values())
+    call_kwargs: dict[str, Any] = {}
+    if config is not None and (accepts_kwargs or "config" in parameters):
+        call_kwargs["config"] = config
+    for key, value in extra_kwargs.items():
+        if accepts_kwargs or key in parameters:
+            call_kwargs[key] = value
+    return call_kwargs
+
+
+async def _call_with_candidates(
+    runnable: Any,
+    method_name: str,
+    value: Any,
+    *,
+    input_key: str,
+    config: Any = None,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> Any:
+    method = getattr(runnable, method_name, None)
+    if not callable(method):
+        raise UnsupportedFrameworkAgentError(f"LangChain entry does not expose {method_name}.")
+
+    call_kwargs = _method_kwargs(method, config, extra_kwargs or {})
+    last_error: Exception | None = None
+    for candidate in _input_candidates(value, input_key):
+        try:
+            return await maybe_await(method(candidate, **call_kwargs))
+        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(f"LangChain entry did not accept any {method_name} input shape.")
+
+
+async def _invoke(
+    runnable: Any,
+    value: Any,
+    *,
+    input_key: str,
+    config: Any = None,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> Any:
+    if callable(getattr(runnable, "ainvoke", None)):
+        return await _call_with_candidates(
+            runnable,
+            "ainvoke",
+            value,
+            input_key=input_key,
+            config=config,
+            extra_kwargs=extra_kwargs,
+        )
+    if callable(getattr(runnable, "invoke", None)):
+        return await _call_with_candidates(
+            runnable,
+            "invoke",
+            value,
+            input_key=input_key,
+            config=config,
+            extra_kwargs=extra_kwargs,
+        )
+    if callable(runnable):
+        call_kwargs = _method_kwargs(runnable, config, extra_kwargs or {})
+        last_error: Exception | None = None
+        for candidate in _input_candidates(value, input_key):
+            try:
+                return await maybe_await(runnable(candidate, **call_kwargs))
+            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 expose ainvoke/invoke or be callable for LangServe compatibility."
+    )
+
+
+async def _stream_from_method(
+    method: Any,
+    value: Any,
+    *,
+    input_key: str,
+    config: Any = None,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> AsyncGenerator[Any, None]:
+    call_kwargs = _method_kwargs(method, config, extra_kwargs or {})
+    last_error: Exception | None = None
+    for candidate in _input_candidates(value, input_key):
+        emitted = False
+        try:
+            stream = method(candidate, **call_kwargs)
+            if inspect.isawaitable(stream):
+                stream = await stream
+            if hasattr(stream, "__aiter__"):
+                async for chunk in stream:
+                    emitted = True
+                    yield chunk
+            else:
+                for chunk in stream:
+                    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
+
+
+def _event_stream_kwargs(method: Any) -> dict[str, str]:
+    try:
+        signature = inspect.signature(method)
+    except (TypeError, ValueError):
+        return {}
+    version = signature.parameters.get("version")
+    if version is not None and version.default is inspect.Parameter.empty:
+        return {"version": "v2"}
+    return {}
+
+
+async def _stream_from_method_with_candidates(
+    method: Any,
+    value: Any,
+    *,
+    input_key: str,
+    kwargs: dict[str, Any] | None = None,
+    config: Any = None,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> AsyncGenerator[Any, None]:
+    call_kwargs = {**_method_kwargs(method, config, extra_kwargs or {}), **(kwargs or {})}
+    last_error: Exception | None = None
+    for candidate in _input_candidates(value, input_key):
+        emitted = False
+        try:
+            stream = method(candidate, **call_kwargs)
+            if inspect.isawaitable(stream):
+                stream = await stream
+            if hasattr(stream, "__aiter__"):
+                async for chunk in stream:
+                    emitted = True
+                    yield chunk
+            else:
+                for chunk in stream:
+                    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 _stream_chunks(
+    runnable: Any,
+    value: Any,
+    *,
+    input_key: str,
+    config: Any = None,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> AsyncGenerator[Any, None]:
+    astream = getattr(runnable, "astream", None)
+    if callable(astream):
+        async for chunk in _stream_from_method(
+            astream,
+            value,
+            input_key=input_key,
+            config=config,
+            extra_kwargs=extra_kwargs,
+        ):
+            yield chunk
+        return
+
+    stream = getattr(runnable, "stream", None)
+    if callable(stream):
+        async for chunk in _stream_from_method(
+            stream,
+            value,
+            input_key=input_key,
+            config=config,
+            extra_kwargs=extra_kwargs,
+        ):
+            yield chunk
+        return
+
+    yield await _invoke(runnable, value, input_key=input_key, config=config, extra_kwargs=extra_kwargs)
+
+
+async def _batch(
+    runnable: Any,
+    values: list[Any],
+    *,
+    input_key: str,
+    config: Any = None,
+    extra_kwargs: dict[str, Any] | None = None,
+) -> list[Any]:
+    abatch = getattr(runnable, "abatch", None)
+    if callable(abatch):
+        try:
+            return await maybe_await(abatch(values, **_method_kwargs(abatch, config, extra_kwargs or {})))
+        except Exception:
+            logger.debug("LangServe compat abatch failed; falling back to per-item invoke.", exc_info=True)
+
+    batch = getattr(runnable, "batch", None)
+    if callable(batch):
+        try:
+            return await maybe_await(batch(values, **_method_kwargs(batch, config, extra_kwargs or {})))
+        except Exception:
+            logger.debug("LangServe compat batch failed; falling back to per-item invoke.", exc_info=True)
+
+    return await asyncio.gather(
+        *[_invoke(runnable, value, input_key=input_key, config=config, extra_kwargs=extra_kwargs) for value in values]
+    )
+
+
+def _sse(event: str, data: Any) -> str:
+    return f"event: {event}\ndata: {json.dumps(_jsonable(data), ensure_ascii=False)}\n\n"
+
+
+def _route_path(prefix: str, path: str) -> str:
+    return f"{prefix}{path}" if prefix else path
+
+
+def _promote_route(app: FastAPI, endpoint: Any, path: str) -> None:
+    routes = app.router.routes
+    route_index = next(
+        (
+            index
+            for index, route in enumerate(routes)
+            if getattr(route, "endpoint", None) is endpoint and getattr(route, "path", None) == path
+        ),
+        None,
+    )
+    if route_index is None:
+        return
+
+    route = routes.pop(route_index)
+    insert_at = len(routes)
+    for index, existing in enumerate(routes):
+        existing_path = getattr(existing, "path", None)
+        if existing_path == path or existing_path in {"", "/"}:
+            insert_at = index
+            break
+    routes.insert(insert_at, route)
+
+
+def attach_langserve_compat_routes(
+    app: FastAPI,
+    runnable: Any,
+    *,
+    input_key: str = "input",
+    prefix: str = "",
+) -> None:
+    """Attach a conservative LangServe-like HTTP contract to a FastAPI app."""
+
+    normalized_prefix = _normalize_prefix(prefix)
+    logger.info("Attaching LangServe compatibility routes at prefix %s", normalized_prefix or "/")
+
+    async def invoke(request: Request) -> JSONResponse:
+        payload = await _request_json(request)
+        config, extra_kwargs = _request_options(payload)
+        run_id = str(uuid4())
+        try:
+            output = await _invoke(
+                runnable,
+                _extract_input(payload),
+                input_key=input_key,
+                config=config,
+                extra_kwargs=extra_kwargs,
+            )
+        except UnsupportedFrameworkAgentError as exc:
+            logger.info("LangServe compat invoke rejected unsupported runnable: %s", exc)
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        except Exception:
+            logger.exception("LangServe compat invoke failed.")
+            raise
+        return JSONResponse({"output": _jsonable(output), "metadata": {"run_id": run_id}})
+
+    async def batch(request: Request) -> JSONResponse:
+        payload = await _request_json(request)
+        config, extra_kwargs = _request_options(payload)
+        raw_inputs = payload.get("inputs") if isinstance(payload, dict) else None
+        if not isinstance(raw_inputs, list):
+            raise HTTPException(status_code=400, detail="Batch request body must include an 'inputs' list.")
+        outputs = await _batch(runnable, raw_inputs, input_key=input_key, config=config, extra_kwargs=extra_kwargs)
+        return JSONResponse(
+            {
+                "output": _jsonable(outputs),
+                "metadata": {"run_ids": [str(uuid4()) for _ in outputs]},
+            }
+        )
+
+    async def stream(request: Request) -> StreamingResponse:
+        payload = await _request_json(request)
+        value = _extract_input(payload)
+        config, extra_kwargs = _request_options(payload)
+
+        async def events() -> AsyncGenerator[str, None]:
+            try:
+                async for chunk in _stream_chunks(
+                    runnable,
+                    value,
+                    input_key=input_key,
+                    config=config,
+                    extra_kwargs=extra_kwargs,
+                ):
+                    yield _sse("data", chunk)
+                yield _sse("end", {})
+            except Exception as exc:
+                logger.exception("LangServe compat stream failed.")
+                yield _sse("error", {"message": str(exc)})
+
+        return StreamingResponse(events(), media_type="text/event-stream")
+
+    async def stream_events(request: Request) -> StreamingResponse:
+        payload = await _request_json(request)
+        value = _extract_input(payload)
+        config, extra_kwargs = _request_options(payload)
+        astream_events = getattr(runnable, "astream_events", None)
+
+        async def events() -> AsyncGenerator[str, None]:
+            try:
+                if callable(astream_events):
+                    async for event in _stream_from_method_with_candidates(
+                        astream_events,
+                        value,
+                        input_key=input_key,
+                        kwargs=_event_stream_kwargs(astream_events),
+                        config=config,
+                        extra_kwargs=extra_kwargs,
+                    ):
+                        yield _sse("data", event)
+                else:
+                    async for chunk in _stream_chunks(
+                        runnable,
+                        value,
+                        input_key=input_key,
+                        config=config,
+                        extra_kwargs=extra_kwargs,
+                    ):
+                        yield _sse(
+                            "data",
+                            {
+                                "event": "on_chain_stream",
+                                "data": {"chunk": _jsonable(chunk), "text": chunk_to_text(chunk)},
+                            },
+                        )
+                yield _sse("end", {})
+            except Exception as exc:
+                logger.exception("LangServe compat stream_events failed.")
+                yield _sse("error", {"message": str(exc)})
+
+        return StreamingResponse(events(), media_type="text/event-stream")
+
+    async def stream_log(request: Request) -> StreamingResponse:
+        payload = await _request_json(request)
+        value = _extract_input(payload)
+        config, extra_kwargs = _request_options(payload)
+        astream_log = getattr(runnable, "astream_log", None)
+        if not callable(astream_log):
+            logger.info("LangServe compat /stream_log requested but runnable does not expose astream_log.")
+            raise HTTPException(
+                status_code=501,
+                detail="stream_log requires a runnable exposing astream_log; this compatibility layer does not synthesize LangServe logs.",
+            )
+
+        async def events() -> AsyncGenerator[str, None]:
+            try:
+                async for event in _stream_from_method_with_candidates(
+                    astream_log,
+                    value,
+                    input_key=input_key,
+                    config=config,
+                    extra_kwargs=extra_kwargs,
+                ):
+                    yield _sse("data", event)
+                yield _sse("end", {})
+            except Exception as exc:
+                logger.exception("LangServe compat stream_log failed.")
+                yield _sse("error", {"message": str(exc)})
+
+        return StreamingResponse(events(), media_type="text/event-stream")
+
+    routes: list[tuple[str, Any]] = [
+        ("/invoke", invoke),
+        ("/batch", batch),
+        ("/stream", stream),
+        ("/stream_events", stream_events),
+        ("/stream_log", stream_log),
+    ]
+    for path, endpoint in routes:
+        full_path = _route_path(normalized_prefix, path)
+        app.add_api_route(full_path, endpoint, methods=["POST"])
+        _promote_route(app, endpoint, full_path)

agentkit/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION = "0.7.3"
+VERSION = "0.7.4"

{agentkit_sdk_python-0.7.3.dist-info → agentkit_sdk_python-0.7.4.dist-info}/METADATA

@@ -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.3.dist-info → agentkit_sdk_python-0.7.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 agentkit/__init__.py,sha256=l27ZMDslc3VhmmnPZJyrqVvTDoZ0LqhCtM5hw0caHcU,1021
 agentkit/errors.py,sha256=UWlXv0ZsXd_oLTMlxuf4u9-XkTdRYeVZueE--Z3JsHU,1214
-agentkit/version.py,sha256=OQzKFr_NITBj2G12DNlZMV3W-rXCEcSJL-iScxwGUXk,653
+agentkit/version.py,sha256=S9zUkhZqaZ0llqw_JF_CXK5OsV7vd2EIpTBKb38hgCI,653
 agentkit/apps/__init__.py,sha256=-oXTjxV3gejpJ8pffTUcUAXw0LfxKCYZJk-_hIJhtLM,1921
 agentkit/apps/base_app.py,sha256=3hZZExL1wyTGWveJEZZoqXN086MzmkVS_WU1vyulIWg,754
 agentkit/apps/utils.py,sha256=IzimIDmT6FS6PV9MLimPh46mq5zT-EjVmnYPxBdyEq0,1934
@@ -40,6 +40,13 @@ agentkit/client/__init__.py,sha256=WHKgNGkpYsJp0xD20drYcxAMDclwDqrfURqxEVv0V1Y,1
 agentkit/client/base_agentkit_client.py,sha256=NV1m2FtboUcMdVUJL2ep75nAwDQ42roiWgl3YKaUSn8,2955
 agentkit/client/base_iam_client.py,sha256=F3ggcZjt14CAcgDYpncF2XGr1zTGnhaOzqEJl4NGHwU,2432
 agentkit/client/base_service_client.py,sha256=zpPUidGMDRAMDnSVjrX7BwuOp4BQdAEk0b8HoXks0TE,15049
+agentkit/frameworks/__init__.py,sha256=NPT7kxcY7shMyA2m1QoxhXzAc9JEvDCNFyWupedTCSY,808
+agentkit/frameworks/_common.py,sha256=0L0cyBQxtlOdi3GbQ_UgaOoHWwenztlKrxUsyvV3hXw,3859
+agentkit/frameworks/langchain.py,sha256=Tcy2HGYqKmcugDSn3OMaD_6uxhsJtZI3o5E8Rw7UJrg,5947
+agentkit/frameworks/langgraph.py,sha256=CHhaX6DcE8McC6Cs31gexEJHqJJ7cFiqh8D6vyQ8FVE,12770
+agentkit/frameworks/serving/__init__.py,sha256=EaR0jzP6np8v1gyD6CYlaRoIY1KgBaFosqCmRUgMc2E,302
+agentkit/frameworks/serving/fastapi_mount.py,sha256=LV6gJunwd7aU8MFdDYSxeaIUYWvYwMl2Am1J07ddP0A,1958
+agentkit/frameworks/serving/langserve.py,sha256=R2R0g95LHcSFJ1BnOm2cxnULv3wQaZNUdm5Aqd-Oq5s,17238
 agentkit/platform/__init__.py,sha256=XD1YoXWJPpLGrP410Tb_psPFKR3LUo3-47UlqayUumo,3464
 agentkit/platform/configuration.py,sha256=lclvtiUUO1D6iwapmPygYGhNJCMfkqt4fHPBCIEqUhE,23378
 agentkit/platform/console_urls.py,sha256=JcnjwyuxN5c4RuXcPevsxy6aInurVFtchqbibJBqjSk,1125
@@ -237,9 +244,9 @@ agentkit/utils/redact.py,sha256=RAtiggxH74eb1Da6Gg0G5SLTVWRaIE5RqYnCozSZozQ,2167
 agentkit/utils/request.py,sha256=1IGxPS3BSCKk1K1_j862_v34xzLEx04CIvrLVb1MsGQ,1625
 agentkit/utils/template_utils.py,sha256=Qjg9V6dEpjAd_yYezIIPwuDsDeeMmp6XTMn5ZECifNc,6336
 agentkit/utils/ve_sign.py,sha256=JfKig7zni8KvdhgbLJXm3Zy_ttyzKrYGUmBY_82_A4Q,12762
-agentkit_sdk_python-0.7.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-agentkit_sdk_python-0.7.3.dist-info/METADATA,sha256=dBa7oZ41ZZ-ndAa9pUUT9ub2f-1IMwXiuc8qZbK8V-A,19611
-agentkit_sdk_python-0.7.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentkit_sdk_python-0.7.3.dist-info/entry_points.txt,sha256=fhzZUsvsLXeB4mPaa0SBQiTBqFT404uDAKPaePAOUAE,58
-agentkit_sdk_python-0.7.3.dist-info/top_level.txt,sha256=ipy8JF-QQ-V0C1oRFLxsyaW8zwrasfJ-zjAh9vgOc7U,9
-agentkit_sdk_python-0.7.3.dist-info/RECORD,,
+agentkit_sdk_python-0.7.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+agentkit_sdk_python-0.7.4.dist-info/METADATA,sha256=s47zJ5ciuJGmqJoi4WcqSMqz8lUM4HWt3eAHAQ4kKGo,19880
+agentkit_sdk_python-0.7.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentkit_sdk_python-0.7.4.dist-info/entry_points.txt,sha256=fhzZUsvsLXeB4mPaa0SBQiTBqFT404uDAKPaePAOUAE,58
+agentkit_sdk_python-0.7.4.dist-info/top_level.txt,sha256=ipy8JF-QQ-V0C1oRFLxsyaW8zwrasfJ-zjAh9vgOc7U,9
+agentkit_sdk_python-0.7.4.dist-info/RECORD,,