agentkit-sdk-python 0.7.10__py3-none-any.whl → 0.7.12__py3-none-any.whl

agentkit/apps/__init__.py

@@ -17,6 +17,9 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from agentkit.apps.a2a_app.a2a_app import AgentkitA2aApp
     from agentkit.apps.agent_server_app.agent_server_app import AgentkitAgentServerApp
+    from agentkit.apps.langgraph_server_app.langgraph_server_app import (
+        AgentkitLangGraphServerApp,
+    )
     from agentkit.apps.mcp_app.mcp_app import AgentkitMCPApp
     from agentkit.apps.simple_app.simple_app import AgentkitSimpleApp
 
@@ -28,6 +31,7 @@ def __getattr__(
     | type["AgentkitMCPApp"]
     | type["AgentkitSimpleApp"]
     | type["AgentkitAgentServerApp"]
+    | type["AgentkitLangGraphServerApp"]
 ):
     if name == "AgentkitA2aApp":
         from agentkit.apps.a2a_app.a2a_app import AgentkitA2aApp
@@ -47,6 +51,12 @@ def __getattr__(
         )
 
         return AgentkitAgentServerApp
+    if name == "AgentkitLangGraphServerApp":
+        from agentkit.apps.langgraph_server_app.langgraph_server_app import (
+            AgentkitLangGraphServerApp,
+        )
+
+        return AgentkitLangGraphServerApp
     raise AttributeError(f"module 'agentkit.apps' has no attribute '{name}'")
 
 
@@ -55,4 +65,5 @@ __all__ = [
     "AgentkitMCPApp",
     "AgentkitSimpleApp",
     "AgentkitAgentServerApp",
+    "AgentkitLangGraphServerApp",
 ]

agentkit/apps/agent_server_app/agent_server_app.py

@@ -39,14 +39,22 @@ from google.adk.evaluation.local_eval_set_results_manager import (
 )
 from google.adk.evaluation.local_eval_sets_manager import LocalEvalSetsManager
 from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
+from google.adk.runners import Runner
 from google.adk.sessions.base_session_service import BaseSessionService
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
 from google.adk.utils.context_utils import Aclosing
 from google.genai import types
 from opentelemetry import trace
 from typing_extensions import override
-from veadk import Agent
-from veadk.memory.short_term_memory import ShortTermMemory
-from veadk.runner import Runner
+
+try:  # pragma: no cover - exercised when users install veadk explicitly.
+    from veadk import Agent as VeadkAgent
+    from veadk.memory.short_term_memory import ShortTermMemory
+    from veadk.runner import Runner as VeadkRunner
+except ImportError:  # pragma: no cover - default migration path avoids veadk.
+    VeadkAgent = None  # type: ignore[assignment]
+    ShortTermMemory = None  # type: ignore[assignment,misc]
+    VeadkRunner = None  # type: ignore[assignment]
 
 from agentkit.apps.agent_server_app.middleware import (
     AgentkitTelemetryHTTPMiddleware,
@@ -64,6 +72,65 @@ from agentkit.apps.base_app import BaseAgentkitApp
 logger = logging.getLogger(__name__)
 
 
+def _is_veadk_short_term_memory(value: Any) -> bool:
+    return ShortTermMemory is not None and isinstance(value, ShortTermMemory)
+
+
+def _is_veadk_agent(value: Any) -> bool:
+    return VeadkAgent is not None and isinstance(value, VeadkAgent)
+
+
+def _resolve_session_service(
+    short_term_memory: BaseSessionService | Any | None,
+) -> BaseSessionService:
+    if short_term_memory is None:
+        return InMemorySessionService()
+    if isinstance(short_term_memory, BaseSessionService):
+        return short_term_memory
+    if _is_veadk_short_term_memory(short_term_memory):
+        return short_term_memory.session_service
+    raise TypeError(
+        "short_term_memory must be a google.adk BaseSessionService, "
+        "a veadk ShortTermMemory, or None."
+    )
+
+
+def _resolve_memory_service(root_agent: BaseAgent) -> Any:
+    if _is_veadk_agent(root_agent):
+        long_term_memory = getattr(root_agent, "long_term_memory", None)
+        if long_term_memory:
+            return long_term_memory
+    return InMemoryMemoryService()
+
+
+def _create_a2a_runner(
+    *,
+    root_agent: BaseAgent,
+    short_term_memory: BaseSessionService | Any | None,
+    session_service: BaseSessionService,
+    memory_service: Any,
+    artifact_service: InMemoryArtifactService,
+    credential_service: InMemoryCredentialService,
+) -> Any:
+    if VeadkRunner is not None and (
+        _is_veadk_agent(root_agent) or _is_veadk_short_term_memory(short_term_memory)
+    ):
+        return VeadkRunner(
+            agent=root_agent,
+            short_term_memory=short_term_memory
+            if _is_veadk_short_term_memory(short_term_memory)
+            else None,
+        )
+    return Runner(
+        agent=root_agent,
+        app_name=root_agent.name,
+        session_service=session_service,
+        memory_service=memory_service,
+        artifact_service=artifact_service,
+        credential_service=credential_service,
+    )
+
+
 async def _call_lifecycle_handler(handler: Any) -> None:
     result = handler()
     if inspect.isawaitable(result):
@@ -143,9 +210,6 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
     ) -> None:
         super().__init__()
 
-        if short_term_memory is None:
-            raise TypeError("short_term_memory is required.")
-
         if app is not None and agent is not None:
             raise TypeError("Only one of 'agent' or 'app' can be provided.")
 
@@ -154,6 +218,8 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
             raise TypeError("Either 'agent' or 'app' must be provided.")
 
         root_agent = entry.root_agent if isinstance(entry, App) else entry
+        session_service = _resolve_session_service(short_term_memory)
+        memory_service = _resolve_memory_service(root_agent)
 
         _artifact_service = InMemoryArtifactService()
         _credential_service = InMemoryCredentialService()
@@ -163,12 +229,8 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
 
         self.server = AdkWebServer(
             agent_loader=AgentKitAgentLoader(entry),
-            session_service=short_term_memory
-            if isinstance(short_term_memory, BaseSessionService)
-            else short_term_memory.session_service,
-            memory_service=root_agent.long_term_memory
-            if isinstance(root_agent, Agent) and root_agent.long_term_memory
-            else InMemoryMemoryService(),
+            session_service=session_service,
+            memory_service=memory_service,
             artifact_service=_artifact_service,
             credential_service=_credential_service,
             eval_sets_manager=_eval_sets_manager,
@@ -176,11 +238,13 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
             agents_dir=".",
         )
 
-        runner = Runner(
-            agent=root_agent,
-            short_term_memory=short_term_memory
-            if isinstance(short_term_memory, ShortTermMemory)
-            else None,
+        runner = _create_a2a_runner(
+            root_agent=root_agent,
+            short_term_memory=short_term_memory,
+            session_service=session_service,
+            memory_service=memory_service,
+            artifact_service=_artifact_service,
+            credential_service=_credential_service,
         )
         _a2a_server_app = to_a2a(agent=root_agent, runner=runner)
 

agentkit/apps/langgraph_server_app/__init__.py

@@ -0,0 +1,5 @@
+from agentkit.apps.langgraph_server_app.langgraph_server_app import (
+    AgentkitLangGraphServerApp,
+)
+
+__all__ = ["AgentkitLangGraphServerApp"]

agentkit/apps/langgraph_server_app/langgraph_server_app.py

@@ -0,0 +1,741 @@
+"""AgentKit protocol routes for LangGraph Server applications."""
+
+from __future__ import annotations
+
+import importlib
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Any
+from uuid import NAMESPACE_URL, uuid4, uuid5
+
+import uvicorn
+from fastapi import Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+from starlette.responses import Response
+from starlette.routing import Mount
+from typing_extensions import override
+
+from agentkit.apps.base_app import BaseAgentkitApp
+
+logger = logging.getLogger(__name__)
+
+_OUTPUT_FIELD_KEYS = ("answer", "output", "final", "response", "text", "messages")
+_THREAD_ID_NAMESPACE = "agentkit:langgraph-server"
+
+
+class AgentkitRunRequest(BaseModel):
+    """Minimal AgentKit run request model for LangGraph Server mode."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    app_name: str = Field(validation_alias=AliasChoices("appName", "app_name"))
+    user_id: str = Field(validation_alias=AliasChoices("userId", "user_id"))
+    session_id: str = Field(validation_alias=AliasChoices("sessionId", "session_id"))
+    new_message: Any | None = Field(
+        default=None,
+        validation_alias=AliasChoices("newMessage", "new_message"),
+    )
+    streaming: bool | None = None
+    state_delta: dict[str, Any] | None = Field(
+        default=None,
+        validation_alias=AliasChoices("stateDelta", "state_delta"),
+    )
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise FileNotFoundError(f"LangGraph config file not found: {path}") from exc
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"LangGraph config file is not valid JSON: {path}") from exc
+    if not isinstance(data, dict):
+        raise ValueError("LangGraph config must be a JSON object.")
+    return data
+
+
+def _load_dotenv(path: Path) -> dict[str, str]:
+    if not path.exists():
+        return {}
+    try:
+        from dotenv.main import DotEnv
+    except ImportError:
+        logger.warning("python-dotenv is not installed; skipping %s.", path)
+        return {}
+    values = DotEnv(dotenv_path=path).dict() or {}
+    return {key: value for key, value in values.items() if value is not None}
+
+
+def _set_env_json(name: str, value: Any) -> None:
+    if value is None:
+        os.environ.pop(name, None)
+    else:
+        os.environ[name] = json.dumps(value)
+
+
+def _json_text(value: Any) -> str:
+    try:
+        return json.dumps(value, ensure_ascii=False, default=str)
+    except Exception:
+        return str(value)
+
+
+def _content_value_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_value_to_text(content[key])
+                if text:
+                    return text
+        return _json_text(content)
+    if isinstance(content, list):
+        return "".join(_content_value_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_value_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 _chunk_delta(accumulated: str, text: str) -> str:
+    if not accumulated:
+        return text
+    if text.startswith(accumulated):
+        return text[len(accumulated) :]
+    return text
+
+
+def _normalize_import_path(config_dir: Path, value: Any) -> Any:
+    if not isinstance(value, str) or ":" not in value:
+        return value
+    path_or_module, variable = value.rsplit(":", 1)
+    if not path_or_module or os.path.isabs(path_or_module):
+        return value
+    if "/" not in path_or_module and not path_or_module.endswith(".py"):
+        return value
+    return f"{(config_dir / path_or_module).resolve()}:{variable}"
+
+
+def _normalize_path_config(config_dir: Path, value: Any) -> Any:
+    if not isinstance(value, dict):
+        return value
+    normalized = dict(value)
+    if "path" in normalized:
+        normalized["path"] = _normalize_import_path(config_dir, normalized["path"])
+    if "app" in normalized:
+        normalized["app"] = _normalize_import_path(config_dir, normalized["app"])
+    return normalized
+
+
+def _normalize_config_paths(config_dir: Path, config: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(config)
+    graphs = config.get("graphs")
+    if isinstance(graphs, dict):
+        normalized_graphs: dict[str, Any] = {}
+        for graph_id, graph_config in graphs.items():
+            if isinstance(graph_config, str):
+                normalized_graphs[graph_id] = _normalize_import_path(config_dir, graph_config)
+            elif isinstance(graph_config, dict):
+                normalized_graphs[graph_id] = _normalize_path_config(config_dir, graph_config)
+            else:
+                normalized_graphs[graph_id] = graph_config
+        normalized["graphs"] = normalized_graphs
+    for key in ("auth", "checkpointer", "http"):
+        normalized[key] = _normalize_path_config(config_dir, config.get(key))
+    return normalized
+
+
+def _graph_source(value: Any) -> str | None:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict) and isinstance(value.get("path"), str):
+        return value["path"]
+    return None
+
+
+def _materialize_lazy_graph_exports(graphs: Any) -> None:
+    if not isinstance(graphs, dict):
+        return
+    for graph_config in graphs.values():
+        source = _graph_source(graph_config)
+        if not source or ":" not in source:
+            continue
+        module_name, variable = source.rsplit(":", 1)
+        if "/" in module_name or module_name.endswith(".py"):
+            continue
+        try:
+            module = importlib.import_module(module_name)
+        except Exception:
+            # This helper only makes lazy module exports visible to LangGraph's
+            # loader. Import errors still belong to the official loader path.
+            continue
+        if variable in module.__dict__:
+            continue
+        try:
+            module.__dict__[variable] = getattr(module, variable)
+        except Exception:
+            continue
+
+
+def _extend_python_path(config_dir: Path, config: dict[str, Any]) -> None:
+    candidates = [config_dir]
+    dependencies = config.get("dependencies")
+    if isinstance(dependencies, list):
+        for dependency in dependencies:
+            if not isinstance(dependency, str):
+                continue
+            dependency_path = (config_dir / dependency).resolve()
+            if dependency_path.is_dir():
+                candidates.append(dependency_path)
+    for candidate in reversed(candidates):
+        value = str(candidate)
+        if value not in sys.path:
+            sys.path.insert(0, value)
+
+
+def _prepare_langgraph_environment(
+    config_path: Path,
+    config: dict[str, Any],
+    *,
+    allow_blocking: bool | None = None,
+) -> None:
+    config_dir = config_path.parent
+    env_config = config.get("env")
+    if isinstance(env_config, str):
+        env_path = (config_dir / env_config).resolve()
+        for key, value in _load_dotenv(env_path).items():
+            os.environ.setdefault(key, value)
+    elif isinstance(env_config, dict):
+        for key, value in env_config.items():
+            if isinstance(key, str) and value is not None:
+                os.environ.setdefault(key, str(value))
+
+    os.environ["LANGSERVE_GRAPHS"] = json.dumps(config.get("graphs", {}))
+    _set_env_json("LANGGRAPH_AUTH", config.get("auth"))
+    _set_env_json("LANGGRAPH_HTTP", config.get("http"))
+    _set_env_json("LANGGRAPH_STORE", config.get("store"))
+    _set_env_json("LANGGRAPH_UI", config.get("ui"))
+    _set_env_json("LANGGRAPH_WEBHOOKS", config.get("webhooks"))
+    _set_env_json("LANGGRAPH_UI_CONFIG", config.get("ui_config"))
+    _set_env_json("LANGGRAPH_CHECKPOINTER", config.get("checkpointer"))
+    os.environ.setdefault("DATABASE_URI", ":memory:")
+    os.environ.setdefault("REDIS_URI", "fake")
+    os.environ.setdefault("MIGRATIONS_PATH", "__inmem")
+    os.environ.setdefault("N_JOBS_PER_WORKER", "1")
+    os.environ.setdefault("LANGSMITH_LANGGRAPH_API_VARIANT", "local_dev")
+    os.environ.setdefault("LANGGRAPH_RUNTIME_EDITION", "inmem")
+    os.environ.setdefault("LANGGRAPH_API_URL", os.environ.get("AGENTKIT_BASE_URL", "http://localhost:8000"))
+    os.environ.setdefault("LANGGRAPH_DISABLE_FILE_PERSISTENCE", "false")
+    if allow_blocking is None:
+        os.environ.setdefault("LANGGRAPH_ALLOW_BLOCKING", "false")
+    else:
+        os.environ["LANGGRAPH_ALLOW_BLOCKING"] = str(allow_blocking).lower()
+    os.environ.setdefault("ALLOW_PRIVATE_NETWORK", "true")
+
+
+def _resolve_graph_id(config: dict[str, Any], graph_id: str | None) -> str:
+    graphs = config.get("graphs")
+    if not isinstance(graphs, dict) or not graphs:
+        raise ValueError("LangGraph config must define at least one graph.")
+    if graph_id:
+        if graph_id not in graphs:
+            raise ValueError(f"Graph id {graph_id!r} was not found in langgraph.json.")
+        return graph_id
+    if len(graphs) > 1:
+        choices = ", ".join(str(key) for key in graphs)
+        raise ValueError(f"Multiple LangGraph graphs found; specify graph_id. Available: {choices}.")
+    return next(iter(graphs))
+
+
+def _content_text(content: Any | None) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, dict):
+        parts = content.get("parts") or []
+        if not parts and isinstance(content.get("text"), str):
+            return content["text"]
+        if not parts and isinstance(content.get("content"), str):
+            return content["content"]
+    else:
+        parts = getattr(content, "parts", None) or []
+    texts: list[str] = []
+    for part in parts:
+        text = part.get("text") if isinstance(part, dict) else getattr(part, "text", None)
+        if text:
+            texts.append(str(text))
+    return "\n".join(texts)
+
+
+def _input_payload(text: str, input_key: str | None) -> dict[str, Any]:
+    if input_key:
+        return {input_key: text}
+    return {"messages": [{"role": "user", "content": text}]}
+
+
+def _update_output_text(data: Any) -> str:
+    if not isinstance(data, dict):
+        return _chunk_to_text(data)
+    for key in _OUTPUT_FIELD_KEYS:
+        if key in data:
+            text = _stream_message_text(data[key]) if key == "messages" else _chunk_to_text(data[key])
+            if text:
+                return text
+    latest = ""
+    for value in data.values():
+        if not isinstance(value, dict):
+            continue
+        for key in _OUTPUT_FIELD_KEYS:
+            if key in value:
+                text = _stream_message_text(value[key]) if key == "messages" else _chunk_to_text(value[key])
+                if text:
+                    latest = text
+    return latest
+
+
+def _stream_chunk(chunk: Any) -> tuple[str, Any]:
+    if isinstance(chunk, dict):
+        return str(chunk.get("type") or chunk.get("event") or ""), chunk.get("data")
+    event = getattr(chunk, "event", "")
+    data = getattr(chunk, "data", None)
+    return str(event or ""), data
+
+
+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):
+        return None
+    if "__interrupt__" in data:
+        interrupts = data.get("__interrupt__")
+        if not isinstance(interrupts, (list, tuple)) or not interrupts:
+            return _jsonable(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
+    for value in data.values():
+        interrupt = _interrupt_payload(value)
+        if interrupt is not None:
+            return interrupt
+    return None
+
+
+def _message_type(value: Any) -> str:
+    if isinstance(value, dict):
+        raw = value.get("type") or value.get("role") or ""
+    else:
+        raw = getattr(value, "type", None) or getattr(value, "role", None) or value.__class__.__name__
+    return str(raw).lower()
+
+
+def _is_ai_message(value: Any) -> bool:
+    message_type = _message_type(value)
+    return message_type in {"ai", "assistant", "model", "aimessage", "aimessagechunk"}
+
+
+def _is_empty_message_content(value: Any) -> bool:
+    if isinstance(value, dict):
+        content = value.get("content")
+        has_text = isinstance(value.get("text"), str) and bool(value.get("text"))
+    else:
+        content = getattr(value, "content", None)
+        has_text = isinstance(getattr(value, "text", None), str) and bool(getattr(value, "text", None))
+    return not has_text and (content is None or content == "" or content == {} or content == [])
+
+
+def _message_candidates(data: Any) -> list[Any]:
+    if isinstance(data, dict):
+        messages = data.get("messages")
+        if isinstance(messages, (list, tuple)):
+            return list(messages)
+        return [data]
+    if isinstance(data, (list, tuple)):
+        return list(data)
+    return [data]
+
+
+def _stream_message_text(data: Any) -> str:
+    latest = ""
+    for candidate in _message_candidates(data):
+        if _is_ai_message(candidate) and not _is_empty_message_content(candidate):
+            text = _chunk_to_text(candidate)
+            if text:
+                latest = text
+    return latest
+
+
+def _agentkit_text_event(agent_name: str, text: str, *, partial: bool) -> dict[str, Any]:
+    return {
+        "invocationId": f"agentkit-langgraph-{uuid4()}",
+        "author": agent_name,
+        "partial": partial,
+        "content": {"role": "model", "parts": [{"text": text}]},
+    }
+
+
+def _interrupt_event(agent_name: str, interrupt: Any) -> dict[str, Any]:
+    return {
+        "invocationId": f"agentkit-langgraph-{uuid4()}",
+        "author": agent_name,
+        "interrupted": True,
+        "errorCode": "LANGGRAPH_INTERRUPT",
+        "errorMessage": "LangGraph execution interrupted and requires resume input.",
+        "customMetadata": {"langgraph_interrupt": interrupt},
+    }
+
+
+def _event_json(event: dict[str, Any]) -> str:
+    return json.dumps(event, ensure_ascii=False, separators=(",", ":"))
+
+
+def _agentkit_thread_id(app_name: str, user_id: str, session_id: str) -> str:
+    raw = f"{_THREAD_ID_NAMESPACE}:{app_name}:{user_id}:{session_id}"
+    return str(uuid5(NAMESPACE_URL, raw))
+
+
+def _session_body(app_name: str, user_id: str, session_id: str, state: dict[str, Any] | None = None) -> dict[str, Any]:
+    return {
+        "id": session_id,
+        "appName": app_name,
+        "userId": user_id,
+        "state": state or {},
+        "events": [],
+    }
+
+
+async def _json_body_or_empty(request: Request) -> dict[str, Any]:
+    body = await request.body()
+    if not body:
+        return {}
+    try:
+        payload = json.loads(body.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+class AgentkitLangGraphServerApp(BaseAgentkitApp):
+    """Run a LangGraph Server app and expose AgentKit-compatible routes.
+
+    LangGraph remains the execution runtime. AgentKit routes translate requests
+    into LangGraph threads/runs so persistence, interrupts, runtime context, and
+    graph factories keep their original LangGraph Server semantics.
+    """
+
+    def __init__(
+        self,
+        *,
+        config_path: str | Path = "langgraph.json",
+        graph_id: str | None = None,
+        input_key: str | None = None,
+        allow_blocking: bool | None = None,
+    ) -> None:
+        super().__init__()
+        self.config_path = Path(config_path).resolve()
+        raw_config = _load_json(self.config_path)
+        self.config = _normalize_config_paths(self.config_path.parent, raw_config)
+        self.graph_id = _resolve_graph_id(self.config, graph_id)
+        self.input_key = input_key
+        _extend_python_path(self.config_path.parent, self.config)
+        _prepare_langgraph_environment(self.config_path, self.config, allow_blocking=allow_blocking)
+        _materialize_lazy_graph_exports(self.config.get("graphs"))
+        try:
+            server_module = importlib.import_module("langgraph_api.server")
+            from langgraph_sdk import get_client
+        except ImportError as exc:
+            raise ImportError(
+                "LangGraph server mode requires langgraph-api and langgraph-sdk. "
+                "Install langgraph-cli[inmem] or use the requirements generated by agentkit migrate."
+            ) from exc
+        self.app = server_module.app
+        self._client = get_client(url=None, api_key=None)
+        self._attach_agentkit_routes()
+
+    def _run_kwargs(self, req: AgentkitRunRequest) -> dict[str, Any]:
+        app_name = req.app_name or self.graph_id
+        thread_id = _agentkit_thread_id(app_name, req.user_id, req.session_id)
+        text = _content_text(req.new_message)
+        configurable = {
+            "thread_id": thread_id,
+            "user_id": req.user_id,
+            "agentkit_session_id": req.session_id,
+            "agentkit_thread_id": thread_id,
+        }
+        if req.state_delta:
+            configurable.update(req.state_delta)
+        return {
+            "thread_id": thread_id,
+            "assistant_id": self.graph_id,
+            "input": _input_payload(text, self.input_key),
+            "config": {"configurable": configurable},
+            "metadata": {
+                "agentkit_user_id": req.user_id,
+                "agentkit_session_id": req.session_id,
+                "agentkit_app_name": req.app_name or self.graph_id,
+            },
+            "if_not_exists": "create",
+        }
+
+    async def _ensure_thread(self, app_name: str, user_id: str, session_id: str, state: dict[str, Any] | None = None) -> None:
+        thread_id = _agentkit_thread_id(app_name, user_id, session_id)
+        metadata = {
+            "agentkit_app_name": app_name,
+            "agentkit_user_id": user_id,
+            "agentkit_session_id": session_id,
+            **(state or {}),
+        }
+        await self._client.threads.create(
+            thread_id=thread_id,
+            if_exists="do_nothing",
+            graph_id=self.graph_id,
+            metadata=metadata,
+        )
+
+    async def _stream_events(self, req: AgentkitRunRequest):
+        await self._ensure_thread(req.app_name or self.graph_id, req.user_id, req.session_id)
+        accumulated_text = ""
+        final_text = ""
+        async for chunk in self._client.runs.stream(
+            **self._run_kwargs(req),
+            stream_mode=["messages", "updates", "values"],
+            version="v2",
+        ):
+            mode, data = _stream_chunk(chunk)
+            if mode == "messages" or mode.startswith("messages/"):
+                text = _stream_message_text(data)
+                delta = _chunk_delta(accumulated_text, text)
+                if delta:
+                    accumulated_text += delta
+                    yield _agentkit_text_event(self.graph_id, delta, partial=True)
+                if text:
+                    final_text = text
+                continue
+            if mode in {"updates", "values"}:
+                interrupt = _interrupt_payload(data)
+                if interrupt is not None:
+                    yield _interrupt_event(self.graph_id, interrupt)
+                    return
+                text = _update_output_text(data)
+                if text:
+                    final_text = text
+        final_text = final_text or accumulated_text
+        if final_text:
+            yield _agentkit_text_event(self.graph_id, final_text, partial=False)
+
+    def _attach_agentkit_routes(self) -> None:
+        async def health(request: Request) -> JSONResponse:
+            del request
+            return JSONResponse({"status": "ok"})
+
+        async def list_apps(request: Request) -> JSONResponse:
+            detailed = request.query_params.get("detailed") == "true"
+            if detailed:
+                return JSONResponse(
+                    {
+                        "apps": [
+                            {
+                                "name": self.graph_id,
+                                "root_agent_name": self.graph_id,
+                                "description": "LangGraph Server app exposed through AgentKit routes",
+                                "language": "python",
+                            }
+                        ]
+                    }
+                )
+            return JSONResponse([self.graph_id])
+
+        async def get_session(request: Request) -> JSONResponse:
+            session_id = request.path_params["session_id"]
+            app_name = request.path_params["app_name"]
+            user_id = request.path_params["user_id"]
+            thread_id = _agentkit_thread_id(app_name, user_id, session_id)
+            response = await self._client.threads.get(thread_id)
+            metadata = response.get("metadata", {}) if isinstance(response, dict) else {}
+            return JSONResponse(_session_body(app_name, user_id, session_id, metadata))
+
+        async def list_sessions(request: Request) -> JSONResponse:
+            app_name = request.path_params["app_name"]
+            user_id = request.path_params["user_id"]
+            response = await self._client.threads.search(
+                metadata={"agentkit_app_name": app_name, "agentkit_user_id": user_id},
+                limit=100,
+            )
+            sessions = [
+                _session_body(
+                    app_name,
+                    user_id,
+                    item.get("metadata", {}).get("agentkit_session_id", item.get("thread_id", "")),
+                    item.get("metadata", {}),
+                )
+                for item in response
+                if isinstance(item, dict) and item.get("thread_id")
+            ]
+            return JSONResponse(sessions)
+
+        async def create_session(request: Request) -> JSONResponse:
+            app_name = request.path_params["app_name"]
+            user_id = request.path_params["user_id"]
+            payload = await _json_body_or_empty(request)
+            session_id = str(payload.get("sessionId") or payload.get("session_id") or uuid4())
+            state = payload.get("state") if isinstance(payload.get("state"), dict) else {}
+            await self._ensure_thread(app_name, user_id, session_id, state)
+            return JSONResponse(_session_body(app_name, user_id, session_id, state))
+
+        async def create_session_with_id(request: Request) -> JSONResponse:
+            app_name = request.path_params["app_name"]
+            user_id = request.path_params["user_id"]
+            session_id = request.path_params["session_id"]
+            payload = await _json_body_or_empty(request)
+            state = payload
+            await self._ensure_thread(app_name, user_id, session_id, state)
+            return JSONResponse(_session_body(app_name, user_id, session_id, state))
+
+        async def delete_session(request: Request) -> Response:
+            thread_id = _agentkit_thread_id(
+                request.path_params["app_name"],
+                request.path_params["user_id"],
+                request.path_params["session_id"],
+            )
+            await self._client.threads.delete(thread_id)
+            return Response(status_code=204)
+
+        async def update_session(request: Request) -> JSONResponse:
+            app_name = request.path_params["app_name"]
+            user_id = request.path_params["user_id"]
+            session_id = request.path_params["session_id"]
+            payload = await _json_body_or_empty(request)
+            state_delta = payload.get("stateDelta") or payload.get("state_delta")
+            state = state_delta if isinstance(state_delta, dict) else {}
+            thread_id = _agentkit_thread_id(app_name, user_id, session_id)
+            await self._client.threads.update(thread_id, metadata=state)
+            return JSONResponse(_session_body(app_name, user_id, session_id, state))
+
+        async def run_agent(request: Request) -> JSONResponse:
+            req = AgentkitRunRequest.model_validate(await request.json())
+            events = [event async for event in self._stream_events(req)]
+            return JSONResponse(events)
+
+        def stream_response(req: AgentkitRunRequest) -> StreamingResponse:
+            async def event_generator():
+                try:
+                    async for event in self._stream_events(req):
+                        yield f"data: {_event_json(event)}\n\n"
+                except Exception as exc:
+                    logger.exception("Error in LangGraph Server AgentKit stream: %s", exc)
+                    yield f"data: {json.dumps({'error': str(exc)}, ensure_ascii=False)}\n\n"
+
+            return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+        async def run_agent_sse(request: Request) -> StreamingResponse:
+            req = AgentkitRunRequest.model_validate(await request.json())
+            return stream_response(req)
+
+        async def invoke_compat(request: Request) -> StreamingResponse:
+            try:
+                payload = await request.json()
+            except Exception:
+                payload = {}
+            prompt = payload.get("prompt") if isinstance(payload, dict) else None
+            if prompt is None:
+                prompt = json.dumps(payload, ensure_ascii=False) if payload else ""
+            user_id = request.headers.get("user_id") or "agentkit_user"
+            session_id = request.headers.get("session_id") or str(uuid4())
+            req = AgentkitRunRequest(
+                app_name=self.graph_id,
+                user_id=user_id,
+                session_id=session_id,
+                new_message={"role": "user", "parts": [{"text": str(prompt)}]},
+                streaming=True,
+            )
+            return stream_response(req)
+
+        routes = [
+            ("/health", health, ["GET"]),
+            ("/list-apps", list_apps, ["GET"]),
+            ("/apps/{app_name}/users/{user_id}/sessions/{session_id}", get_session, ["GET"]),
+            ("/apps/{app_name}/users/{user_id}/sessions", list_sessions, ["GET"]),
+            ("/apps/{app_name}/users/{user_id}/sessions", create_session, ["POST"]),
+            ("/apps/{app_name}/users/{user_id}/sessions/{session_id}", create_session_with_id, ["POST"]),
+            ("/apps/{app_name}/users/{user_id}/sessions/{session_id}", delete_session, ["DELETE"]),
+            ("/apps/{app_name}/users/{user_id}/sessions/{session_id}", update_session, ["PATCH"]),
+            ("/run", run_agent, ["POST"]),
+            ("/run_sse", run_agent_sse, ["POST"]),
+            ("/invoke", invoke_compat, ["POST"]),
+        ]
+        existing = {
+            (getattr(route, "path", ""), tuple(sorted(getattr(route, "methods", ()) or ())))
+            for route in getattr(self.app, "routes", [])
+        }
+        for path, endpoint, methods in routes:
+            key = (path, tuple(sorted(methods)))
+            if key not in existing:
+                self.app.add_route(path, endpoint, methods=methods)
+                route = self.app.routes.pop()
+                insert_at = next(
+                    (
+                        index
+                        for index, existing_route in enumerate(self.app.routes)
+                        if isinstance(existing_route, Mount)
+                        and getattr(existing_route, "path", None) == ""
+                    ),
+                    len(self.app.routes),
+                )
+                self.app.routes.insert(insert_at, route)
+
+    @override
+    def run(self, host: str | None = None, port: int = 8000) -> None:
+        uvicorn.run(self.app, host=host or "0.0.0.0", port=port)

agentkit/auth/admin.py

@@ -344,6 +344,7 @@ def sso_setup(
     bucket = bucket or f"agentkit-cli-{acct}"
     url = publish_discovery(
         coords, bucket=bucket, custom_domain=custom_domain, access_key=api.ak, secret_key=api.sk,
+        session_token=api.token,
     )
     if custom_domain:
         manual.append(
@@ -360,6 +361,7 @@ def publish_discovery(
     custom_domain: str | None = None,
     access_key: str | None = None,
     secret_key: str | None = None,
+    session_token: str | None = None,
 ) -> str:
     """Publish the discovery doc to TOS static hosting (real https). Returns the login URL.
 
@@ -379,8 +381,9 @@ def publish_discovery(
         ) from exc
     ak = access_key or _os.getenv("VOLCENGINE_ACCESS_KEY")
     sk = secret_key or _os.getenv("VOLCENGINE_SECRET_KEY")
+    token = session_token or _os.getenv("VOLCENGINE_SESSION_TOKEN")
     endpoint = f"tos-{coords.region}.volces.com"
-    client = tos.TosClientV2(ak, sk, endpoint, coords.region)
+    client = tos.TosClientV2(ak, sk, endpoint, coords.region, security_token=token)
     try:
         client.create_bucket(bucket, acl=tos.ACLType.ACL_Public_Read)
     except Exception as exc:  # noqa: BLE001

agentkit/frameworks/langgraph.py

@@ -6,6 +6,7 @@ from collections.abc import AsyncGenerator, Iterable
 import hashlib
 import inspect
 import json
+from dataclasses import dataclass
 from typing import Any
 
 try:
@@ -40,6 +41,12 @@ LANGGRAPH_PENDING_INTERRUPT_STATE_KEY = "agentkit:langgraph:pending_interrupt"
 _OUTPUT_FIELD_KEYS = ("answer", "output", "final", "response", "text", "messages")
 
 
+@dataclass(frozen=True)
+class _FactoryCall:
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+
+
 def _method_kwargs(method: Any, kwargs: dict[str, Any]) -> dict[str, Any]:
     try:
         signature = inspect.signature(method)
@@ -51,6 +58,66 @@ def _method_kwargs(method: Any, kwargs: dict[str, Any]) -> dict[str, Any]:
     return {key: value for key, value in kwargs.items() if accepts_kwargs or key in parameters}
 
 
+def _factory_call(factory: Any, config: dict[str, Any] | None) -> _FactoryCall:
+    if not callable(factory):
+        raise UnsupportedFrameworkAgentError(
+            "LangGraph graph_factory=True requires a callable entry that "
+            "returns a compiled graph-like object."
+        )
+
+    try:
+        signature = inspect.signature(factory)
+    except (TypeError, ValueError):
+        return _FactoryCall(args=(config,), kwargs={})
+
+    parameters = list(signature.parameters.values())
+    required = [
+        param
+        for param in parameters
+        if param.default is inspect.Parameter.empty
+        and param.kind
+        in {
+            inspect.Parameter.POSITIONAL_ONLY,
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            inspect.Parameter.KEYWORD_ONLY,
+        }
+    ]
+    if len(required) > 1:
+        names = ", ".join(param.name for param in required)
+        raise UnsupportedFrameworkAgentError(
+            "LangGraph Server graph factory entries may require at most one "
+            f"RunnableConfig argument; required parameters found: {names}."
+        )
+
+    if any(param.kind == inspect.Parameter.VAR_POSITIONAL for param in parameters):
+        return _FactoryCall(args=(config,), kwargs={})
+
+    if required:
+        param = required[0]
+        if param.kind == inspect.Parameter.KEYWORD_ONLY:
+            return _FactoryCall(args=(), kwargs={param.name: config})
+        return _FactoryCall(args=(config,), kwargs={})
+
+    optional_config = next(
+        (
+            param
+            for param in parameters
+            if param.name in {"config", "runnable_config"}
+            and param.kind
+            in {
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+            }
+        ),
+        None,
+    )
+    if optional_config is None:
+        return _FactoryCall(args=(), kwargs={})
+    if optional_config.kind == inspect.Parameter.KEYWORD_ONLY:
+        return _FactoryCall(args=(), kwargs={optional_config.name: config})
+    return _FactoryCall(args=(config,), kwargs={})
+
+
 def _jsonable(value: Any) -> Any:
     try:
         json.dumps(value, ensure_ascii=False)
@@ -119,6 +186,7 @@ class LangGraphAgentkitBridge(BaseAgent):
     """Adapt a compiled LangGraph graph to AgentKit's ADK runtime boundary."""
 
     _graph: Any = PrivateAttr()
+    _graph_factory: bool = PrivateAttr(default=False)
     _input_key: str | None = PrivateAttr(default=None)
     _stream_nodes: frozenset[str] = PrivateAttr(default_factory=frozenset)
 
@@ -130,9 +198,11 @@ class LangGraphAgentkitBridge(BaseAgent):
         description: str = "LangGraph agent adapted for AgentKit runtime",
         input_key: str | None = None,
         stream_nodes: Iterable[str] | str | None = None,
+        graph_factory: bool = False,
     ) -> None:
         super().__init__(name=name, description=description)
         self._graph = graph
+        self._graph_factory = graph_factory
         self._input_key = input_key
         if isinstance(stream_nodes, str):
             nodes = (stream_nodes,)
@@ -160,6 +230,15 @@ class LangGraphAgentkitBridge(BaseAgent):
             thread_id = session_id
         return {"configurable": {"thread_id": thread_id}}
 
+    async def _graph_for_run(self, config: dict[str, Any] | None) -> Any:
+        if not self._graph_factory:
+            return self._graph
+        call = _factory_call(self._graph, config)
+        graph = self._graph(*call.args, **call.kwargs)
+        if inspect.isawaitable(graph):
+            graph = await graph
+        return graph
+
     def _pending_interrupt(self, ctx: InvocationContext) -> Any | None:
         session = getattr(ctx, "session", None)
         state = getattr(session, "state", None)
@@ -217,12 +296,12 @@ class LangGraphAgentkitBridge(BaseAgent):
             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)
+    async def _call_once(self, graph: Any, payload: Any, config: dict[str, Any] | None) -> Any:
+        ainvoke = getattr(graph, "ainvoke", None)
         if callable(ainvoke):
             return await ainvoke(payload, **_method_kwargs(ainvoke, {"config": config}))
 
-        invoke = getattr(self._graph, "invoke", None)
+        invoke = getattr(graph, "invoke", None)
         if callable(invoke):
             return invoke(payload, **_method_kwargs(invoke, {"config": config}))
 
@@ -236,8 +315,8 @@ class LangGraphAgentkitBridge(BaseAgent):
             return ["messages", "updates"]
         return "updates"
 
-    def _sync_stream(self, payload: Any, config: dict[str, Any] | None):
-        stream_fn = getattr(self._graph, "stream", None)
+    def _sync_stream(self, graph: Any, payload: Any, config: dict[str, Any] | None):
+        stream_fn = getattr(graph, "stream", None)
         if not callable(stream_fn):
             return None
         stream_mode = self._stream_mode()
@@ -273,15 +352,15 @@ class LangGraphAgentkitBridge(BaseAgent):
 
         return iterate_attempts()
 
-    async def _stream_graph(self, payload: Any, config: dict[str, Any] | None, *, prefer_sync: bool = False):
+    async def _stream_graph(self, graph: Any, payload: Any, config: dict[str, Any] | None, *, prefer_sync: bool = False):
         if prefer_sync:
-            stream = self._sync_stream(payload, config)
+            stream = self._sync_stream(graph, payload, config)
             if stream is not None:
                 for item in stream:
                     yield item
                 return
 
-        astream = getattr(self._graph, "astream", None)
+        astream = getattr(graph, "astream", None)
         if callable(astream):
             stream_mode = self._stream_mode()
             attempts = [
@@ -312,7 +391,7 @@ class LangGraphAgentkitBridge(BaseAgent):
             if last_error is not None:
                 raise last_error
 
-        stream = self._sync_stream(payload, config)
+        stream = self._sync_stream(graph, payload, config)
         if stream is not None:
             for item in stream:
                 yield item
@@ -337,12 +416,13 @@ class LangGraphAgentkitBridge(BaseAgent):
         config = self._graph_config(ctx)
         resume_pending = self._pending_interrupt(ctx) is not None
         payload = self._run_payload(ctx)
+        graph = await self._graph_for_run(config)
         accumulated_text = ""
         last_update: Any = None
         pending_update_text = ""
         streamed = False
 
-        async for item in self._stream_graph(payload, config, prefer_sync=resume_pending):
+        async for item in self._stream_graph(graph, payload, config, prefer_sync=resume_pending):
             streamed = True
             mode = ""
             data = item
@@ -400,7 +480,7 @@ class LangGraphAgentkitBridge(BaseAgent):
             update_text = pending_update_text or _update_output_text(last_update)
             final_text = update_text or accumulated_text
         else:
-            final_text = _update_output_text(await self._call_once(payload, config))
+            final_text = _update_output_text(await self._call_once(graph, payload, config))
 
         if final_text:
             yield self._final_event(ctx, final_text, clear_pending_interrupt=resume_pending)

agentkit/frameworks/migration.py

@@ -92,6 +92,9 @@ def _call_zero_arg_factory(target: Any, object_path: str) -> Any:
 
     result = target()
     if inspect.isawaitable(result):
+        close = getattr(result, "close", None)
+        if callable(close):
+            close()
         raise TypeError(
             f"Entry factory {object_path!r} returned an awaitable object. "
             "Async factories are not supported by generated migration apps; "

agentkit/frameworks/strands.py

@@ -330,6 +330,8 @@ def _result_to_text(result: Any) -> str:
     message_text = _message_to_text(getattr(result, "message", None))
     if message_text:
         return message_text
+    if hasattr(result, "message") or hasattr(result, "structured_output"):
+        return ""
     if isinstance(result, Exception):
         return str(result)
     if isinstance(getattr(result, "results", None), dict):

agentkit/toolkit/cli/sandbox/model_config.py

@@ -83,8 +83,12 @@ MODEL_PROVIDER_CONFIGS: dict[str, ModelProviderConfig] = {
     ModelProviderType.MODEL_SQUARE.value: ModelProviderConfig(
         model_base_url="https://ark.cn-beijing.volces.com/api/v3",
         anthropic_base_url="https://ark.cn-beijing.volces.com/api/compatible",
-        default_model_name="deepseek-v4-flash-260425",
+        default_model_name="glm-5-2-260617",
         models={
+            "glm-5-2-260617": ModelSpec(
+                supports_reasoning_summaries=True,
+                context_window=DEFAULT_MODEL_CONTEXT_WINDOW,
+            ),
             "doubao-seed-2-0-pro-260215": ModelSpec(
                 supports_reasoning_summaries=True,
                 context_window=LIMITED_MODEL_CONTEXT_WINDOW,
@@ -435,7 +439,11 @@ def build_codex_config_toml(
             'wire_api = "responses"',
             # OAuth (ChatGPT login) providers carry no API key - codex uses the injected
             # auth.json via `requires_openai_auth`; all others use the CODEX_API_KEY env.
-            ("requires_openai_auth = true" if requires_openai_auth else 'env_key = "CODEX_API_KEY"'),
+            (
+                "requires_openai_auth = true"
+                if requires_openai_auth
+                else 'env_key = "CODEX_API_KEY"'
+            ),
             "",
             "[tui]",
             "show_tooltips = false",
@@ -552,7 +560,7 @@ if [ -n "$REQ_CODEX_BASE_URL" ]; then
   CODEX_BASE_URL="$REQ_CODEX_BASE_URL"
 fi
 
-CODEX_MODEL="${CODEX_MODEL:-deepseek-v4-flash-260425}"
+CODEX_MODEL="${CODEX_MODEL:-glm-5-2-260617}"
 CODEX_BASE_URL="${CODEX_BASE_URL:-https://ark.cn-beijing.volces.com/api/v3}"
 
 : >"$ENV_FILE"
@@ -653,8 +661,10 @@ def _build_model_catalog_item(model_name: str, spec: ModelSpec) -> dict:
 
 def infer_model_spec(model_name: str) -> ModelSpec:
     normalized_model_name = model_name.strip().lower()
-    if normalized_model_name == "glm-5.2" or normalized_model_name.startswith(
-        "deepseek-v4"
+    if (
+        normalized_model_name == "glm-5.2"
+        or normalized_model_name.startswith("glm-5-")
+        or normalized_model_name.startswith("deepseek-v4")
     ):
         context_window = DEFAULT_MODEL_CONTEXT_WINDOW
     else:

agentkit/version.py

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

{agentkit_sdk_python-0.7.10.dist-info → agentkit_sdk_python-0.7.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.7.10
+Version: 0.7.12
 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

{agentkit_sdk_python-0.7.10.dist-info → agentkit_sdk_python-0.7.12.dist-info}/RECORD

@@ -1,17 +1,19 @@
 agentkit/__init__.py,sha256=l27ZMDslc3VhmmnPZJyrqVvTDoZ0LqhCtM5hw0caHcU,1021
 agentkit/errors.py,sha256=UWlXv0ZsXd_oLTMlxuf4u9-XkTdRYeVZueE--Z3JsHU,1214
-agentkit/version.py,sha256=elnLJh2dU0M8vTwaqXfngYOIRybHJiYIXsanO6aGgDY,654
-agentkit/apps/__init__.py,sha256=-oXTjxV3gejpJ8pffTUcUAXw0LfxKCYZJk-_hIJhtLM,1921
+agentkit/version.py,sha256=UZFajXkO3LMaoMxV_yKH2_pQpvhunh05rfkX_ftKnUQ,654
+agentkit/apps/__init__.py,sha256=_Na1A4NSaMbVfPbsFKj2U-yI5mytD7W5skMaAOGbauY,2328
 agentkit/apps/base_app.py,sha256=3hZZExL1wyTGWveJEZZoqXN086MzmkVS_WU1vyulIWg,754
 agentkit/apps/utils.py,sha256=IzimIDmT6FS6PV9MLimPh46mq5zT-EjVmnYPxBdyEq0,1934
 agentkit/apps/a2a_app/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 agentkit/apps/a2a_app/a2a_app.py,sha256=mFuPFuqRlGdQ2VIjQq2_gtQKWwnkwSjSmIMRnammWJU,7605
 agentkit/apps/a2a_app/telemetry.py,sha256=vR8tf7EHLor62cxs5PBx4mrfHeOaV1a7Xryqlu8nGCU,4290
 agentkit/apps/agent_server_app/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
-agentkit/apps/agent_server_app/agent_server_app.py,sha256=aqLgDGaqV921-BZIe7ZiWMbV9Xjlo7d-cNkDaiXFJo4,17245
+agentkit/apps/agent_server_app/agent_server_app.py,sha256=jq0DR6AZObeBQ1zZO_-qzO6n_ABov9lolL2g0n_ywPE,19535
 agentkit/apps/agent_server_app/middleware.py,sha256=2gLCRN-JYjYsTQzHqRBU69S2OI8gD5AdbrFeoGzDcM0,2962
 agentkit/apps/agent_server_app/origin.py,sha256=hzpftk8cW71uFw0KKsBAvrXiIOF8E6Bjo_MS5gDxSYM,5785
 agentkit/apps/agent_server_app/telemetry.py,sha256=FLJsxJHj4Vg3sfIZnWYm442_Dv-zmxTIPqRgvgwVIFQ,4398
+agentkit/apps/langgraph_server_app/__init__.py,sha256=ta7KORxpAc8cUGFusoTFBZFHuVaQbcsWst8CKBepg1c,146
+agentkit/apps/langgraph_server_app/langgraph_server_app.py,sha256=gEqH6CTeuwE255m06IaTOoc7l5V3_OJF0tiForJqLaQ,29146
 agentkit/apps/mcp_app/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 agentkit/apps/mcp_app/mcp_app.py,sha256=2ngFbKcC3OsWNPwU0aoS-D8JVBC7-mFpXqj7sgcvUY8,5886
 agentkit/apps/mcp_app/telemetry.py,sha256=ObzEoJrQK9Yu_3KsCslJejIhKkACZl5c87KHMFblvgI,3929
@@ -23,7 +25,7 @@ agentkit/auth/__init__.py,sha256=eIW6ziL3rtBYEupfmqq8MshZ40wL3muYjCQRikFG_j0,364
 agentkit/auth/_openapi.py,sha256=ofFX7Ch-1xQeOvwUYRU4YwGKUqDgIfI8lsnk8Vbi12s,8230
 agentkit/auth/_redact.py,sha256=Ef3yLlWj6jw0G6gZKy3cY64X6sm0jhzor8qx8b0Dp4A,911
 agentkit/auth/_sigv4.py,sha256=yAbFD57g3cBvCkGTVJap0BCakQeukyR_FlzMDYZdTkw,3375
-agentkit/auth/admin.py,sha256=U9rvVFx1rD5dsSrL0eQVPezBVI9vhaSrdc6QkM7jVKY,23393
+agentkit/auth/admin.py,sha256=JDyKIptLKMQOAp8DjUvrCRnJ2jER6cZUrXoUJcojMDU,23554
 agentkit/auth/credential_hosting.py,sha256=lFFYseYHkqCUsv1djtK3EFR1XvESmw6l1Zgu1CcwIa8,24280
 agentkit/auth/errors.py,sha256=eNNdzXP35QAlYy-jM5I9CQZCSS9rW0cp5_1F0I75JcU,1448
 agentkit/auth/model_login.py,sha256=_30pbZgs22o4UtGF03dMgFRN9yE4OSyLqXJm9JhEe7E,13775
@@ -44,10 +46,10 @@ agentkit/frameworks/__init__.py,sha256=a9fu6cjLFn8Mq82sIo7rPT1gZGzi_QfCuFWpyoa2I
 agentkit/frameworks/_common.py,sha256=0L0cyBQxtlOdi3GbQ_UgaOoHWwenztlKrxUsyvV3hXw,3859
 agentkit/frameworks/agentcore.py,sha256=L5bdqzVukm7V6esIttPZSHFEc8JiqysU8YxA6_pBYRQ,12849
 agentkit/frameworks/langchain.py,sha256=Tcy2HGYqKmcugDSn3OMaD_6uxhsJtZI3o5E8Rw7UJrg,5947
-agentkit/frameworks/langgraph.py,sha256=fc2IbK6PYzSK5a4iPMGa2A9_eMW3Asd0nFlY8JuGLiY,14866
-agentkit/frameworks/migration.py,sha256=j8MxFvAFKkDsTy_e1l5bN-B276AE7rwxLrHuBodNcfc,4385
+agentkit/frameworks/langgraph.py,sha256=hSYfh9Gy2vj3UM7zbpl4ZoawypTy6fFbz-Y0YrSS8p0,17651
+agentkit/frameworks/migration.py,sha256=OTIsrqxVOWlrP10D7_2Zt1tGFNWEmmAHqsTuLB7YBhY,4480
 agentkit/frameworks/model_replacement.py,sha256=EtRl617CZqYLNQ6CYKtK4XzObsv778jQCgWpBaJJahk,5196
-agentkit/frameworks/strands.py,sha256=PdetmUHDWg4JK3ZxOmnLo81ZLTlHHRISuTznm51jPRE,20792
+agentkit/frameworks/strands.py,sha256=KFeTsdVpOyOh-SJvC3jcW8FdhR_5Y3NaGDd6zbuYrXE,20885
 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
@@ -137,7 +139,7 @@ agentkit/toolkit/cli/sandbox/cli_shell.py,sha256=f-PJmIClEgsNrY-e8wKhc9th7r7H5_Z
 agentkit/toolkit/cli/sandbox/cli_web.py,sha256=nvBEp99yqA3-sDNA_PBn7jOG_VgkHTw_8lDSvRNYSRA,2496
 agentkit/toolkit/cli/sandbox/env_config.py,sha256=mQKKtRG7FXG0vhizEMpkzH9_g2agCQt9FDKgSGf-Xjs,26184
 agentkit/toolkit/cli/sandbox/git_config.py,sha256=y0omhCCsH33XCMEpmbtAdHM8pevRFQdil1-JfOV8RTo,6097
-agentkit/toolkit/cli/sandbox/model_config.py,sha256=j-foFsln5rs67EtLNNzdpPFlro6l_k3IIdpq1YA89j8,23478
+agentkit/toolkit/cli/sandbox/model_config.py,sha256=A3TagXhjYB1HWtsEDIRVUPmVOfc6c_e7qcipSkqCBLk,23752
 agentkit/toolkit/cli/sandbox/sandbox_client.py,sha256=6HEmHOzXW7LVohGi4NmmeX3d-GQHyz6-C4svwI_Sfr8,15007
 agentkit/toolkit/cli/sandbox/session_create.py,sha256=LOUqRxhvY4YmaVTnxLQBlLswpq6J6TDtOR6o9yt6Iz0,14947
 agentkit/toolkit/cli/sandbox/session_sync.py,sha256=yLcRN4dw0dHHYk1kgDvjF8jBv5GnHV8xOLtKtsQTm6s,3152
@@ -251,9 +253,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=IsRKRshTKpOMkNv4bDJoNWUcsBaMGeq-jHCniPMAyo8,13327
-agentkit_sdk_python-0.7.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-agentkit_sdk_python-0.7.10.dist-info/METADATA,sha256=W66BJetdVKDgdZnYnM0avT84252zSrODeB5Mszn_DWQ,21409
-agentkit_sdk_python-0.7.10.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-agentkit_sdk_python-0.7.10.dist-info/entry_points.txt,sha256=fhzZUsvsLXeB4mPaa0SBQiTBqFT404uDAKPaePAOUAE,58
-agentkit_sdk_python-0.7.10.dist-info/top_level.txt,sha256=ipy8JF-QQ-V0C1oRFLxsyaW8zwrasfJ-zjAh9vgOc7U,9
-agentkit_sdk_python-0.7.10.dist-info/RECORD,,
+agentkit_sdk_python-0.7.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+agentkit_sdk_python-0.7.12.dist-info/METADATA,sha256=K90dgH6c8sePnET9IhGsL-u8BwcOcT0E58EdsKMXG4U,21409
+agentkit_sdk_python-0.7.12.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agentkit_sdk_python-0.7.12.dist-info/entry_points.txt,sha256=fhzZUsvsLXeB4mPaa0SBQiTBqFT404uDAKPaePAOUAE,58
+agentkit_sdk_python-0.7.12.dist-info/top_level.txt,sha256=ipy8JF-QQ-V0C1oRFLxsyaW8zwrasfJ-zjAh9vgOc7U,9
+agentkit_sdk_python-0.7.12.dist-info/RECORD,,