agentengine-sdk-python 0.7.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

ksadk/a2a/client.py

@@ -1,309 +0,0 @@
-"""Client helpers for invoking remote A2A agents from KsADK code."""
-
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from typing import Any
-from uuid import uuid4
-
-import httpx
-from a2a.client import Client, ClientConfig, ClientFactory
-from a2a.types import (
-    Message,
-    MessageSendConfiguration,
-    Part,
-    Role,
-    Task,
-    TaskArtifactUpdateEvent,
-    TaskState,
-    TaskStatusUpdateEvent,
-    TextPart,
-)
-from a2a.utils import get_artifact_text, get_message_text
-
-_FAILED_TASK_STATES = {
-    TaskState.canceled,
-    TaskState.failed,
-    TaskState.rejected,
-}
-
-
-def _build_text_message(
-    text: str,
-    *,
-    context_id: str | None = None,
-    task_id: str | None = None,
-) -> Message:
-    return Message(
-        role=Role.user,
-        parts=[Part(root=TextPart(text=text))],
-        message_id=str(uuid4()),
-        context_id=context_id,
-        task_id=task_id,
-    )
-
-
-def _task_output(task: Task) -> str:
-    outputs = []
-    for artifact in task.artifacts or []:
-        artifact_text = get_artifact_text(artifact, delimiter="")
-        if artifact_text:
-            outputs.append(artifact_text)
-    if outputs:
-        return "".join(outputs)
-
-    if task.status.message is not None:
-        return get_message_text(task.status.message)
-
-    if task.history:
-        for message in reversed(task.history):
-            if message.role == Role.agent:
-                message_text = get_message_text(message)
-                if message_text:
-                    return message_text
-
-    return ""
-
-
-def _task_error(task: Task) -> str:
-    text = _task_output(task)
-    if text:
-        return text
-    return f"Remote A2A task ended in state: {task.status.state.value}"
-
-
-class RemoteA2AClient:
-    """Thin client wrapper for interacting with a remote A2A endpoint."""
-
-    def __init__(
-        self,
-        endpoint: str,
-        *,
-        http_client: httpx.AsyncClient | None = None,
-        timeout: float = 120.0,
-    ) -> None:
-        self.endpoint = endpoint.rstrip("/") or endpoint
-        self.timeout = timeout
-        self._http_client = http_client
-        self._owns_http_client = http_client is None
-        self._streaming_client: Client | None = None
-        self._blocking_client: Client | None = None
-
-    async def get_card(self) -> Any:
-        client = await self._ensure_client(streaming=True)
-        return await client.get_card()
-
-    async def invoke(
-        self,
-        text: str,
-        *,
-        context_id: str | None = None,
-        task_id: str | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        client = await self._ensure_client(streaming=False)
-        message = _build_text_message(
-            text,
-            context_id=context_id,
-            task_id=task_id,
-        )
-        final_task: Task | None = None
-
-        async for event in client.send_message(
-            message,
-            configuration=MessageSendConfiguration(blocking=True),
-            request_metadata=metadata,
-        ):
-            if isinstance(event, Message):
-                return {
-                    "output": get_message_text(event),
-                    "task_id": event.task_id,
-                    "context_id": event.context_id,
-                    "message": event,
-                }
-            final_task, _ = event
-
-        if final_task is None:
-            raise RuntimeError("A2A response did not include a task result")
-
-        self._raise_for_failed_task(final_task)
-        return {
-            "output": _task_output(final_task),
-            "task_id": final_task.id,
-            "context_id": final_task.context_id,
-            "task": final_task,
-        }
-
-    async def stream(
-        self,
-        text: str,
-        *,
-        context_id: str | None = None,
-        task_id: str | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> AsyncIterator[dict[str, Any]]:
-        client = await self._ensure_client(streaming=True)
-        message = _build_text_message(
-            text,
-            context_id=context_id,
-            task_id=task_id,
-        )
-        emitted_output = False
-        latest_task: Task | None = None
-
-        async for event in client.send_message(
-            message,
-            configuration=MessageSendConfiguration(blocking=True),
-            request_metadata=metadata,
-        ):
-            if isinstance(event, Message):
-                text_output = get_message_text(event)
-                if text_output:
-                    emitted_output = True
-                    yield {
-                        "delta": text_output,
-                        "type": "text",
-                        "task_id": event.task_id,
-                        "context_id": event.context_id,
-                    }
-                return
-
-            latest_task, update = event
-            if isinstance(update, TaskArtifactUpdateEvent):
-                artifact_text = get_artifact_text(update.artifact)
-                if artifact_text:
-                    emitted_output = True
-                    yield {
-                        "delta": artifact_text,
-                        "type": "text",
-                        "task_id": update.task_id,
-                        "context_id": update.context_id,
-                    }
-                continue
-
-            if isinstance(update, TaskStatusUpdateEvent) and update.final:
-                self._raise_for_failed_task(latest_task)
-
-        if latest_task is None:
-            return
-
-        self._raise_for_failed_task(latest_task)
-        if emitted_output:
-            return
-
-        task_text = _task_output(latest_task)
-        if task_text:
-            yield {
-                "delta": task_text,
-                "type": "text",
-                "task_id": latest_task.id,
-                "context_id": latest_task.context_id,
-            }
-
-    async def close(self) -> None:
-        if self._owns_http_client and self._http_client is not None:
-            await self._http_client.aclose()
-        self._http_client = None
-        self._streaming_client = None
-        self._blocking_client = None
-
-    async def __aenter__(self) -> "RemoteA2AClient":
-        await self._ensure_client(streaming=True)
-        return self
-
-    async def __aexit__(self, *_: Any) -> None:
-        await self.close()
-
-    async def _ensure_client(self, *, streaming: bool) -> Client:
-        cached_client = (
-            self._streaming_client if streaming else self._blocking_client
-        )
-        if cached_client is not None:
-            return cached_client
-
-        if self._http_client is None:
-            self._http_client = httpx.AsyncClient(timeout=self.timeout)
-
-        client = await ClientFactory.connect(
-            self.endpoint,
-            client_config=ClientConfig(
-                httpx_client=self._http_client,
-                streaming=streaming,
-                polling=False,
-                accepted_output_modes=["text/plain"],
-            ),
-        )
-        if streaming:
-            self._streaming_client = client
-        else:
-            self._blocking_client = client
-        return client
-
-    @staticmethod
-    def _raise_for_failed_task(task: Task) -> None:
-        if task.status.state in _FAILED_TASK_STATES:
-            raise RuntimeError(_task_error(task))
-
-
-class RemoteA2AAgent:
-    """Runner-like adapter for using a remote A2A endpoint inside KsADK flows."""
-
-    def __init__(
-        self,
-        endpoint: str,
-        *,
-        name: str = "remote_a2a_agent",
-        http_client: httpx.AsyncClient | None = None,
-        timeout: float = 120.0,
-    ) -> None:
-        self.name = name
-        self._client = RemoteA2AClient(
-            endpoint=endpoint,
-            http_client=http_client,
-            timeout=timeout,
-        )
-
-    async def get_card(self) -> Any:
-        return await self._client.get_card()
-
-    async def invoke(self, input_data: dict[str, Any]) -> dict[str, Any]:
-        response = await self._client.invoke(
-            str(input_data.get("input", "")),
-            context_id=input_data.get("context_id") or input_data.get("session_id"),
-            task_id=input_data.get("task_id"),
-            metadata=self._build_metadata(input_data),
-        )
-        return {
-            "output": response["output"],
-            "task_id": response.get("task_id"),
-            "context_id": response.get("context_id"),
-        }
-
-    async def stream(
-        self,
-        input_data: dict[str, Any],
-    ) -> AsyncIterator[dict[str, Any]]:
-        async for event in self._client.stream(
-            str(input_data.get("input", "")),
-            context_id=input_data.get("context_id") or input_data.get("session_id"),
-            task_id=input_data.get("task_id"),
-            metadata=self._build_metadata(input_data),
-        ):
-            yield event
-
-    async def close(self) -> None:
-        await self._client.close()
-
-    @staticmethod
-    def _build_metadata(input_data: dict[str, Any]) -> dict[str, Any] | None:
-        metadata = dict(input_data.get("metadata") or {})
-
-        state = input_data.get("state")
-        if isinstance(state, dict) and state:
-            metadata["state"] = dict(state)
-
-        branch = input_data.get("branch")
-        if isinstance(branch, str) and branch:
-            metadata["branch"] = branch
-
-        return metadata or None

ksadk/runners/utils/langfuse.py

@@ -1,230 +0,0 @@
-"""
-Langfuse 集成工具
-
-提供 LangChain/LangGraph Runner 共用的 Langfuse 集成功能
-"""
-
-import logging
-import os
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-# 全局缓存
-_langfuse_callback = None
-_cloud_monitor_langfuse_callback = None
-
-
-def _env_flag_enabled(name: str) -> bool:
-    return os.getenv(name, "").strip().lower() in {"1", "true", "yes", "on"}
-
-
-def _env_flag_disabled(name: str) -> bool:
-    return os.getenv(name, "").strip().lower() in {"0", "false", "no", "off", "disabled"}
-
-
-def _first_env(*names: str) -> str:
-    for name in names:
-        value = os.getenv(name, "").strip()
-        if value:
-            return value
-    return ""
-
-
-def _create_langfuse_callback(
-    *,
-    label: str,
-    public_key: str,
-    secret_key: str = "",
-    host: str = "",
-) -> Any | None:
-    try:
-        from langfuse import Langfuse
-        from langfuse.langchain import CallbackHandler
-        from opentelemetry.sdk.resources import Resource
-        from opentelemetry.sdk.trace import TracerProvider
-
-        resource_attributes = {}
-        service_name = os.getenv("OTEL_SERVICE_NAME", "").strip()
-        if service_name:
-            resource_attributes["service.name"] = service_name
-        tracer_provider = TracerProvider(resource=Resource.create(resource_attributes))
-        Langfuse(
-            public_key=public_key,
-            secret_key=secret_key or None,
-            base_url=host or None,
-            tracer_provider=tracer_provider,
-        )
-        try:
-            handler = CallbackHandler(public_key=public_key)
-        except TypeError:
-            handler = CallbackHandler()
-        logger.info(
-            "%s Langfuse CallbackHandler initialized "
-            "(host: %s public_key_present=%s secret_key_present=%s isolated_provider=True)",
-            label,
-            host or "default",
-            bool(public_key),
-            bool(secret_key),
-        )
-        return handler
-    except ImportError as e:
-        logger.warning("Langfuse not installed for %s callback: %s", label, e)
-        return None
-    except Exception as e:
-        logger.error("Failed to create %s Langfuse CallbackHandler: %s", label, e)
-        return None
-
-
-def get_langfuse_callback():
-    """获取 Langfuse CallbackHandler
-
-    Returns:
-        CallbackHandler 实例，未配置时返回 None
-    """
-    global _langfuse_callback
-
-    if not _env_flag_enabled("LANGFUSE_USE_CALLBACK"):
-        logger.debug("Langfuse CallbackHandler disabled; using OTLP direct exporter by default")
-        return None
-
-    if _langfuse_callback is not None:
-        return _langfuse_callback
-
-    # 检查是否配置了 Langfuse
-    public_key = os.getenv("LANGFUSE_PUBLIC_KEY", "").strip()
-    if not public_key:
-        return None
-
-    _langfuse_callback = _create_langfuse_callback(
-        label="Primary",
-        public_key=public_key,
-        secret_key=os.getenv("LANGFUSE_SECRET_KEY", "").strip(),
-        host=_first_env("LANGFUSE_HOST", "LANGFUSE_BASE_URL"),
-    )
-    return _langfuse_callback
-
-
-def get_cloud_monitor_langfuse_callback():
-    """获取云监控 Langfuse SDK CallbackHandler。"""
-    global _cloud_monitor_langfuse_callback
-
-    if not _env_flag_enabled("LANGFUSE_USE_CALLBACK"):
-        return None
-    if _env_flag_disabled("CLOUD_MONITOR_LANGFUSE_ENABLED"):
-        logger.info(
-            "CloudMonitor Langfuse CallbackHandler disabled by CLOUD_MONITOR_LANGFUSE_ENABLED"
-        )
-        return None
-    if _cloud_monitor_langfuse_callback is not None:
-        return _cloud_monitor_langfuse_callback
-
-    public_key = os.getenv("CLOUD_MONITOR_LANGFUSE_PUBLIC_KEY", "").strip()
-    secret_key = os.getenv("CLOUD_MONITOR_LANGFUSE_SECRET_KEY", "").strip()
-    host = _first_env("CLOUD_MONITOR_LANGFUSE_HOST", "CLOUD_MONITOR_OTLP_ENDPOINT")
-    if not public_key and not secret_key and not host:
-        return None
-    if not public_key or not secret_key or not host:
-        logger.warning(
-            "CloudMonitor Langfuse CallbackHandler skipped: public_key_present=%s "
-            "secret_key_present=%s host_present=%s",
-            bool(public_key),
-            bool(secret_key),
-            bool(host),
-        )
-        return None
-
-    _cloud_monitor_langfuse_callback = _create_langfuse_callback(
-        label="CloudMonitor",
-        public_key=public_key,
-        secret_key=secret_key,
-        host=host,
-    )
-    return _cloud_monitor_langfuse_callback
-
-
-def get_langfuse_callbacks() -> list[Any]:
-    """获取所有 Langfuse CallbackHandler，原平台和云监控各自独立。"""
-    callbacks = []
-    primary = get_langfuse_callback()
-    if primary:
-        callbacks.append(primary)
-
-    cloud_monitor = get_cloud_monitor_langfuse_callback()
-    if cloud_monitor:
-        callbacks.append(cloud_monitor)
-
-    return callbacks
-
-
-def get_langfuse_metadata(session_id: str = None) -> dict:
-    """获取 Langfuse 的 metadata 字典
-
-    通过 metadata 字段传递 trace 属性:
-    - langfuse_user_id
-    - langfuse_session_id
-    - langfuse_tags
-
-    Args:
-        session_id: 会话 ID (可选)
-
-    Returns:
-        包含 Langfuse 属性的 metadata 字典
-    """
-    metadata = {}
-
-    if session_id:
-        metadata["langfuse_session_id"] = session_id
-
-    try:
-        from ksadk.configs import settings
-
-        agent_config = settings.agent
-
-        if agent_config.user_id:
-            metadata["langfuse_user_id"] = agent_config.user_id
-
-        if not session_id and agent_config.session_id:
-            metadata["langfuse_session_id"] = agent_config.session_id
-
-        tags = list(agent_config.tags or [])
-        if agent_config.environment and agent_config.environment not in tags:
-            tags.append(agent_config.environment)
-        if agent_config.agent_name and agent_config.agent_name not in tags:
-            tags.append(agent_config.agent_name)
-        if tags:
-            metadata["langfuse_tags"] = tags
-
-    except (ImportError, Exception):
-        pass
-
-    return metadata
-
-
-def prepare_trace_metadata(session_id: str = None) -> tuple:
-    """准备 Trace 元数据
-
-    Returns:
-        (user_id, tags, version, agent_name) 元组
-    """
-    user_id = None
-    tags = []
-    version = None
-    agent_name = None
-
-    try:
-        from ksadk.configs import settings
-
-        agent_config = settings.agent
-        user_id = agent_config.user_id
-        tags = list(agent_config.tags or [])
-        version = agent_config.version
-        agent_name = agent_config.agent_name
-
-        if agent_config.environment and agent_config.environment not in tags:
-            tags.append(agent_config.environment)
-
-    except (ImportError, Exception):
-        pass
-
-    return user_id, tags, version, agent_name