agent-api-server 2.2.1__tar.gz → 2.2.1a0__tar.gz

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agent-api-server
-Version: 2.2.1
+Version: 2.2.1a0
 Summary: A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot
 Keywords: fastapi,langgraph,agent,api-server
 Author: Zijie Zhang
@@ -21,6 +21,7 @@ Requires-Dist: fastmcp (>=2.13.0,<3.0.0)
 Requires-Dist: langchain (>=1.2.0,<2.0.0)
 Requires-Dist: langchain-core (>=1.2.5,<2.0.0)
 Requires-Dist: langchain-mcp-adapters (>=0.2.1,<0.3.0)
+Requires-Dist: langfuse (>=4.3.1,<5.0.0)
 Requires-Dist: langgraph (>=1.0.6,<2.0.0)
 Requires-Dist: langgraph-checkpoint (>=4.0.0,<5.0.0)
 Requires-Dist: langgraph-checkpoint-postgres (>=3.0.3,<4.0.0)

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/api/v1/thread.py

@@ -21,6 +21,7 @@ from agent_api_server.shared.message import (
     message_generator,
     langchain_to_chat_message
 )
+from agent_api_server.observability import with_langfuse_config
 
 logger = logging.getLogger(__name__)
 api_router = APIRouter()
@@ -99,7 +100,13 @@ def _get_run_config(thread_id: str, ts_tenant: str, ei_token: str, graph_name: s
     config["configurable"]["TSTenant"] = ts_tenant
     config["configurable"]["EIToken"] = ei_token
     config["configurable"]["files"] = files or []
-    return config
+    return with_langfuse_config(
+        config,
+        thread_id=thread_id,
+        graph_name=graph_name,
+        ts_tenant=ts_tenant,
+        files=files,
+    )
 
 
 async def _check_stop_flag(thread_id: str, storage: AsyncRedisThreadStorage):

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/configs/config.py

@@ -1,5 +1,5 @@
 from pydantic_settings import BaseSettings, SettingsConfigDict
-from pydantic import Field
+from pydantic import Field, PrivateAttr
 from pathlib import Path
 from typing import Optional
 from dotenv import load_dotenv
@@ -7,11 +7,19 @@ from dotenv import load_dotenv
 
 class SSOConfig(BaseSettings):
     SSO_URL: str = Field(
-        default="http://sso/v4.0", description="The URL of SSO service"
+        default="", description="The URL of SSO service. Leave empty to disable SSO integration."
     )
     CLIENT_ID: str = Field(default="", description="The client-id of server")
     CLIENT_SECRET: str = Field(default="", description="The client secret of server")
-    CLIENT_TOKEN: str = Field(default="", description="The client token of server")
+    _client_token: str = PrivateAttr(default="")
+
+    @property
+    def CLIENT_TOKEN(self) -> str:
+        return self._client_token
+
+    @CLIENT_TOKEN.setter
+    def CLIENT_TOKEN(self, value: str) -> None:
+        self._client_token = value or ""
 
 
 class CacheConfig(BaseSettings):
@@ -63,7 +71,7 @@ class LoggingConfig(BaseSettings):
 
 class ModelManagerServiceConfig(BaseSettings):
     MODEL_MANAGER_SERVICE_URL: str = Field(
-        default="https://api-am-ensaas.axa.wise-paas.com.cn", description="The URL of model manager service url"
+        default="", description="The URL of model manager service url. Leave empty to disable Model Management integration."
     )
 
     SERVICE_EXTERNAL_URL: str = Field(
@@ -71,7 +79,7 @@ class ModelManagerServiceConfig(BaseSettings):
     )
 
     MODEL_MANAGER_REDIS_URL: str = Field(
-        default="redis://localhost:6379/0", description="Redis server URL which used by model_manager, format is: redis://host:port/db"
+        default="", description="Redis server URL which used by model_manager, format is: redis://host:port/db"
     )
 
     MODEL_MANAGER_NATS_URL: str =  Field(
@@ -160,4 +168,3 @@ class Config(PostgresConfig, CacheConfig, LoggingConfig, SSOConfig, WebServerCon
         env_file_encoding="utf-8",
         extra="ignore",
     )
-

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/dynamic_llm/dynamic_llm.py

@@ -24,6 +24,20 @@ from agent_api_server.shared.util_func import set_model_config, get_env
 logger = logging.getLogger(__name__)
 
 
+def _has_model_management_config() -> bool:
+    return bool(global_config.MODEL_MANAGER_SERVICE_URL and global_config.CLIENT_TOKEN)
+
+
+def _dedupe(values: List[str]) -> List[str]:
+    seen = set()
+    result = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+
+
 class DynamicLLM(Runnable):
     _instance_lock = threading.Lock()
     _llm_cache: Dict[str, ModelInstance] = {}
@@ -169,12 +183,17 @@ class DynamicLLM(Runnable):
     @contextmanager
     def _get_model_instance(self, llm_config: Dict[str, Any], config: RunnableConfig):
         if self.use_sys_llm:
-            logger.info(f"use_sys_llm is {self.use_sys_llm}, so call model with system llm configuration, CLIENT_TOKEN is {global_config.CLIENT_TOKEN}")
+            logger.info(f"use_sys_llm is {self.use_sys_llm}, so call model with system llm configuration")
+            if not _has_model_management_config():
+                raise ValueError(
+                    "System LLM mode requires Model Management configuration. "
+                    "Configure SSO_URL and MODEL_MANAGER_SERVICE_URL, or disable use_sys_llm."
+                )
 
             self._model = ModelInstanceFactory.get_model_instance(
-                model_managment_url=os.environ['MODEL_MANAGER_SERVICE_URL'],
+                model_managment_url=global_config.MODEL_MANAGER_SERVICE_URL,
                 config_type=self.config_type,
-                token=os.environ['CLIENT_TOKEN'],
+                token=global_config.CLIENT_TOKEN,
                 app_id=llm_config.get('agent_id'),
                 app_name=llm_config.get('agent_id'),
             )
@@ -188,6 +207,12 @@ class DynamicLLM(Runnable):
                     f"Local cache does not contain LLM credentials for tenant '{ts_id}'. "
                     f"Retrieve the credentials from Model Management and configure them in the system.")
 
+                if not _has_model_management_config():
+                    raise ValueError(
+                        "LLM credentials are missing and Model Management is not configured. "
+                        "Provide model credentials in the runtime config, or configure SSO_URL and MODEL_MANAGER_SERVICE_URL."
+                    )
+
                 m_client =  ModelManageClient(global_config.MODEL_MANAGER_SERVICE_URL, global_config.CLIENT_TOKEN)
                 model_info = m_client.get_agent_models(agent_id, ts_id)
 
@@ -284,15 +309,38 @@ class DynamicLLM(Runnable):
             self.use_sys_llm = True if value == "true" else False
 
         config = {
-            "provider": configurable.get(self._get_config_key("PROVIDER", ts_tenant)),
-            "model": configurable.get(self._get_config_key("MODEL", ts_tenant)),
-            "credentials": configurable.get(self._get_config_key("CREDENTIALS", ts_tenant)),
+            "provider": self._get_config_value(configurable, "PROVIDER", ts_tenant),
+            "model": self._get_config_value(configurable, "MODEL", ts_tenant),
+            "credentials": self._get_config_value(configurable, "CREDENTIALS", ts_tenant),
             "agent_id": graph_name,
             "ts_tenant": ts_tenant
         }
 
         return config
 
+    def _get_config_value(self, configurable: Dict[str, Any], field: str, ts_tenant: Optional[str] = None) -> Any:
+        for key in self._get_config_key_candidates(field, ts_tenant):
+            value = configurable.get(key)
+            if value not in (None, ""):
+                return value
+        return None
+
+    def _get_config_key_candidates(self, field: str, ts_tenant: Optional[str] = None) -> List[str]:
+        keys = []
+
+        if ts_tenant:
+            keys.append(self._get_config_key(field, ts_tenant))
+
+        keys.append(self._get_config_key(field))
+
+        if self.tool_name != "default":
+            default_key = "_".join([self.config_type.value, field])
+            if ts_tenant:
+                keys.append(f"{default_key}_{ts_tenant}")
+            keys.append(default_key)
+
+        return _dedupe(keys)
+
     def _get_config_key(self, field: str, ts_tenant: Optional[str] = None) -> str:
         parts = [self.tool_name.upper(), self.config_type.value, field] if self.tool_name != "default" else [
             self.config_type.value, field]
@@ -311,6 +359,9 @@ class DynamicLLM(Runnable):
         if config is None:
             return True
 
+        if config.get('provider') == 'ollama':
+            return False
+
         credentials = config.get('credentials')
         if not credentials:
             return True
@@ -328,4 +379,4 @@ class DynamicLLM(Runnable):
         return len(cls._llm_cache)
 
     def __repr__(self) -> str:
-        return f"DynamicLLM(tool_name={self.tool_name}, config_type={self.config_type})"
+        return f"DynamicLLM(tool_name={self.tool_name}, config_type={self.config_type})"

agent_api_server-2.2.1a0/agent_api_server/observability/__init__.py

@@ -0,0 +1,3 @@
+from .langfuse import is_langfuse_enabled, shutdown_langfuse, with_langfuse_config
+
+__all__ = ["is_langfuse_enabled", "shutdown_langfuse", "with_langfuse_config"]

agent_api_server-2.2.1a0/agent_api_server/observability/langfuse.py

@@ -0,0 +1,84 @@
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+FALSE_VALUES = {"0", "false", "no", "off"}
+
+
+def is_langfuse_enabled() -> bool:
+    tracing_enabled = os.getenv("LANGFUSE_TRACING_ENABLED", "true").strip().lower()
+    if tracing_enabled in FALSE_VALUES:
+        return False
+
+    return bool(os.getenv("LANGFUSE_PUBLIC_KEY") and os.getenv("LANGFUSE_SECRET_KEY"))
+
+
+def _merge_unique(values: List[str]) -> List[str]:
+    seen = set()
+    merged = []
+    for value in values:
+        if value and value not in seen:
+            seen.add(value)
+            merged.append(value)
+    return merged
+
+
+def _new_langfuse_callback_handler():
+    from langfuse.langchain import CallbackHandler
+
+    return CallbackHandler()
+
+
+def with_langfuse_config(
+        config: Dict[str, Any],
+        *,
+        thread_id: str,
+        graph_name: str,
+        ts_tenant: Optional[str],
+        files: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    if not is_langfuse_enabled():
+        return config
+
+    configured = dict(config)
+    configured["configurable"] = dict(config.get("configurable") or {})
+
+    tags = _merge_unique(list(configured.get("tags") or []) + ["agent-api-server", graph_name])
+    metadata = dict(configured.get("metadata") or {})
+    metadata.update({
+        "langfuse_user_id": ts_tenant or "anonymous",
+        "langfuse_session_id": thread_id,
+        "langfuse_trace_name": f"{graph_name}:{thread_id}",
+        "langfuse_tags": tags,
+        "thread_id": thread_id,
+        "graph_name": graph_name,
+        "tenant": ts_tenant,
+        "file_count": len(files or []),
+    })
+
+    callbacks = list(configured.get("callbacks") or [])
+    try:
+        callbacks.append(_new_langfuse_callback_handler())
+    except Exception:
+        logger.exception("Failed to initialize Langfuse callback handler")
+        return config
+
+    configured["callbacks"] = callbacks
+    configured["metadata"] = metadata
+    configured["tags"] = tags
+    configured["run_name"] = configured.get("run_name") or graph_name
+    return configured
+
+
+def shutdown_langfuse() -> None:
+    if not is_langfuse_enabled():
+        return
+
+    try:
+        from langfuse import get_client
+
+        get_client().shutdown()
+    except Exception:
+        logger.exception("Failed to shutdown Langfuse client")

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/service.py

@@ -10,7 +10,7 @@ from fastapi import HTTPException
 from fastapi import FastAPI
 from agent_api_server.api.v1.api import api_router
 from pydantic_settings import BaseSettings
-from typing import List, Any
+from typing import List, Any, Optional
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from pathlib import Path
@@ -27,6 +27,7 @@ from agent_api_server.cache.redis_cache import AsyncRedisThreadStorage
 from agent_api_server.memeory.postgres import AsyncPostgresCheckpointer
 from contextlib import asynccontextmanager
 from agent_api_server.shared.util_func import parse_agent_config
+from agent_api_server.observability import shutdown_langfuse
 
 WELCOME_ART = """
 ╦  ┌─┐┌┐┌┌─┐╔═╗┬─┐┌─┐┌─┐┬ ┬
@@ -73,6 +74,9 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 
             await AsyncRedisThreadStorage.close_worker_instance()
             logger.info(f"Redis connection pool closed in worker {os.getpid()}")
+
+            shutdown_langfuse()
+            logger.info(f"Langfuse client shutdown completed in worker {os.getpid()}")
         except Exception as e:
             logger.error(f"Error closing connection pool in worker {os.getpid()}, error message is {str(e)}")
 
@@ -127,6 +131,44 @@ def create_fastapi_app() -> FastAPI:
     return app
 
 
+def _configured(value: Any) -> bool:
+    return bool(str(value or "").strip())
+
+
+def _ensure_client_token_from_sso() -> bool:
+    if _configured(global_config.CLIENT_TOKEN):
+        logger.info("Using existing runtime client token; skip SSO client token generation")
+        return True
+
+    if not _configured(global_config.SSO_URL):
+        logger.warning("SSO_URL is not configured; skip SSO client token generation")
+        return False
+
+    sso_service = SSOService(sso_config=SSOConfig(
+        sso_address=global_config.SSO_URL,
+        client_id=global_config.CLIENT_ID,
+        client_secret=global_config.CLIENT_SECRET,
+    ))
+    client_id, client_secret = sso_service.get_client_id_and_secret()
+    logger.debug(f"Client ID: {client_id}, Client Secret: {client_secret}")
+
+    global_config.CLIENT_TOKEN = sso_service.generate_client_token(client_id, client_secret)
+    logger.info("Generated runtime client token from SSO")
+    return True
+
+
+def _has_model_management_service() -> bool:
+    return _configured(global_config.MODEL_MANAGER_SERVICE_URL)
+
+
+def _determine_listener_type_optional() -> Optional[ListenerType]:
+    if hasattr(global_config, 'MODEL_MANAGER_NATS_URL') and global_config.MODEL_MANAGER_NATS_URL:
+        return ListenerType.NATS
+    if hasattr(global_config, 'MODEL_MANAGER_REDIS_URL') and global_config.MODEL_MANAGER_REDIS_URL:
+        return ListenerType.REDIS
+    return None
+
+
 async def init_fastapi_server():
     print_welcome(host=settings.host, port=settings.port)
 
@@ -242,19 +284,9 @@ async def init_fastapi_server():
                 await checkpointer.close_worker_instance()
 
         try:
-            sso_service = SSOService(sso_config=SSOConfig(
-                sso_address=global_config.SSO_URL,
-                client_id=global_config.CLIENT_ID,
-                client_secret=global_config.CLIENT_SECRET,
-            ))
-            client_id, client_secret = sso_service.get_client_id_and_secret()
-            logger.debug(f"Client ID: {client_id}, Client Secret: {client_secret}")
-
-            global_config.CLIENT_TOKEN = sso_service.generate_client_token(client_id, client_secret)
-            os.environ['CLIENT_TOKEN'] = global_config.CLIENT_TOKEN
-            logger.info(f"Generated Client Token: {os.environ['CLIENT_TOKEN']}")
+            has_client_token = _ensure_client_token_from_sso()
         except Exception as e:
-            logger.error(f"Failed during agent registration or listener setup: {e}")
+            logger.error(f"Failed to prepare client token from SSO: {e}")
             raise
 
         if not global_config.AGENT_AUTO_REGISTRATION:
@@ -267,6 +299,22 @@ async def init_fastapi_server():
             )
             return
 
+        if not has_client_token:
+            logger.warning(
+                "Agent auto-registration is enabled but runtime client token is unavailable and SSO_URL is not configured.\n"
+                "Skip automatic registration and model configuration listener startup.\n"
+                "Configure SSO_URL to enable these platform integrations.\n"
+            )
+            return
+
+        if not _has_model_management_service():
+            logger.warning(
+                "Agent auto-registration is enabled but MODEL_MANAGER_SERVICE_URL is not configured.\n"
+                "Skip automatic registration and model configuration listener startup.\n"
+                "Set MODEL_MANAGER_SERVICE_URL to enable Model Management integration.\n"
+            )
+            return
+
         try:
             for agent in agents:
                 agent["agent_url"] = global_config.SERVICE_EXTERNAL_URL
@@ -277,12 +325,15 @@ async def init_fastapi_server():
             )
             await agent_registry.register_all(agents=agents)
 
-            try:
-                listener_type = determine_listener_type()
-                logger.info(f"Using {listener_type.name} listener based on configuration")
-            except ValueError as e:
-                logger.error(str(e))
-                raise
+            listener_type = _determine_listener_type_optional()
+            if listener_type is None:
+                logger.warning(
+                    "MODEL_MANAGER_REDIS_URL and MODEL_MANAGER_NATS_URL are not configured. "
+                    "Skip model configuration listener startup."
+                )
+                return
+
+            logger.info(f"Using {listener_type.name} listener based on configuration")
 
             for agent in agents:
                 listener = create_listener(
@@ -312,15 +363,14 @@ async def init_fastapi_server():
 
 
 def determine_listener_type() -> ListenerType:
-    if hasattr(global_config, 'MODEL_MANAGER_NATS_URL') and global_config.MODEL_MANAGER_NATS_URL:
-        return ListenerType.NATS
-    elif hasattr(global_config, 'MODEL_MANAGER_REDIS_URL') and global_config.MODEL_MANAGER_REDIS_URL:
-        return ListenerType.REDIS
-    else:
-        raise ValueError(
-            "No valid message broker configured. "
-            "Please set either MODEL_MANAGER_NATS_URL or MODEL_MANAGER_REDIS_URL"
-        )
+    listener_type = _determine_listener_type_optional()
+    if listener_type is not None:
+        return listener_type
+
+    raise ValueError(
+        "No valid message broker configured. "
+        "Please set either MODEL_MANAGER_NATS_URL or MODEL_MANAGER_REDIS_URL"
+    )
 
 def run_mcp_server(log_cfg):
     try:

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/shared/get_model_info.py

@@ -79,6 +79,29 @@ class ConfigKeyBuilder:
 
         return "_".join(parts)
 
+    @staticmethod
+    def get_candidates(tool_name: str, field: str, ts_tenant: Optional[str] = None) -> list[str]:
+        keys = []
+
+        if ts_tenant:
+            keys.append(ConfigKeyBuilder.get_key(tool_name, field, ts_tenant))
+
+        keys.append(ConfigKeyBuilder.get_key(tool_name, field))
+
+        if tool_name.lower() != "default":
+            default_key = ConfigKeyBuilder.get_key("default", field)
+            if ts_tenant:
+                keys.append(f"{default_key}_{ts_tenant}")
+            keys.append(default_key)
+
+        seen = set()
+        result = []
+        for key in keys:
+            if key not in seen:
+                seen.add(key)
+                result.append(key)
+        return result
+
 
 class CredentialsParser:
     """Parses credential data from various formats."""
@@ -178,13 +201,26 @@ class LLMConfigManager:
         graph_name = configurable.get("graph_name")
 
         return LLMConfig(
-            provider=configurable.get(self.key_builder.get_key(tool_name, "PROVIDER", ts_tenant)),
-            model=configurable.get(self.key_builder.get_key(tool_name, "MODEL", ts_tenant)),
-            credentials=configurable.get(self.key_builder.get_key(tool_name, "CREDENTIALS", ts_tenant)),
+            provider=self._get_config_value(configurable, tool_name, "PROVIDER", ts_tenant),
+            model=self._get_config_value(configurable, tool_name, "MODEL", ts_tenant),
+            credentials=self._get_config_value(configurable, tool_name, "CREDENTIALS", ts_tenant),
             agent_id=graph_name,
             ts_tenant=ts_tenant
         )
 
+    def _get_config_value(
+            self,
+            configurable: Dict[str, Any],
+            tool_name: str,
+            field: str,
+            ts_tenant: Optional[str] = None
+    ) -> Optional[Any]:
+        for key in self.key_builder.get_candidates(tool_name, field, ts_tenant):
+            value = configurable.get(key)
+            if value not in (None, ""):
+                return value
+        return None
+
     def get_api_version(self, tool_name: str, config: Optional[RunnableConfig]) -> str:
         if not config:
             logger.debug(f"No config provided for tool: {tool_name}")
@@ -422,6 +458,12 @@ def get_chat_model_information(tool_name: str, config: Optional[RunnableConfig])
     use_sys_llm = configurable.get('use_sys_llm')
 
     if use_sys_llm == 'true':
+        if not global_config.MODEL_MANAGER_SERVICE_URL or not global_config.CLIENT_TOKEN:
+            raise ValueError(
+                "System LLM mode requires Model Management configuration. "
+                "Configure SSO_URL and MODEL_MANAGER_SERVICE_URL, or disable use_sys_llm."
+            )
+
         from llm_sdk.llm import ModelInstanceFactory
         _model = ModelInstanceFactory.get_model_instance(
             model_managment_url=global_config.MODEL_MANAGER_SERVICE_URL,
@@ -488,4 +530,4 @@ def get_chat_llm_model_base_model_name(tool_name: str, config: Optional[Runnable
     if provider == 'azure_openai':
         return config_manager.get_base_model_name(tool_name, config)
     else:
-        return ''
+        return ''

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/shared/message.py

@@ -17,6 +17,7 @@ from agent_api_server.shared.base_model import ChatMessage
 from fastapi import Body, status, HTTPException
 from agent_api_server.cache.redis_cache import AsyncRedisThreadStorage
 from ..schema.context import Context
+from agent_api_server.observability import with_langfuse_config
 
 logger = logging.getLogger(__name__)
 
@@ -344,13 +345,37 @@ async def message_generator(
         interrupted_tasks = [
             task for task in state_get.tasks if hasattr(task, "interrupts") and task.interrupts
         ]
+        run_config = with_langfuse_config(
+            {
+                "configurable": {
+                    **dict(get_env(ts_tenant=ts_tenant)),
+                    "graph_name": state.graph_name,
+                    "thread_id": state.thread_id,
+                    "TSTenant": ts_tenant,
+                    "EIToken": ei_token,
+                    "files": files or [],
+                }
+            },
+            thread_id=state.thread_id,
+            graph_name=state.graph_name,
+            ts_tenant=ts_tenant,
+            files=files,
+        )
+        run_context = Context(
+            ts_tenant=ts_tenant,
+            input=inputs,
+            ei_token=ei_token,
+            graph_name=state.graph_name,
+            files=files or [],
+            config=get_env(ts_tenant=ts_tenant),
+        )
 
         if interrupted_tasks:
             async for stream_event in graph_instance.astream(
                     Command(resume=inputs.get("resume", "")),
-                    config={"configurable": {**dict(get_env(ts_tenant=ts_tenant)), "graph_name": state.graph_name, "thread_id": state.thread_id, "TSTenant": ts_tenant, "EIToken": ei_token, "files": files or []}},
+                    config=run_config,
                     stream_mode=["updates","messages", "custom"],
-                    context=Context(ts_tenant=ts_tenant, input=inputs, ei_token=ei_token, graph_name=state.graph_name, files=files or [], config=get_env(ts_tenant=ts_tenant)),
+                    context=run_context,
                     subgraphs=True
             ):
                 async for chunk in handle_stream_event(stream_event):
@@ -360,9 +385,9 @@ async def message_generator(
 
             async for stream_event in graph_instance.astream(
                     inputs or {},
-                    config={"configurable": {**dict(get_env(ts_tenant=ts_tenant)), "graph_name": state.graph_name, "thread_id": state.thread_id, "TSTenant": ts_tenant, "EIToken": ei_token, "files": files or []}},
+                    config=run_config,
                     stream_mode=["updates","messages", "custom"],
-                    context=Context(ts_tenant=ts_tenant, input=inputs, ei_token=ei_token, graph_name=state.graph_name, files=files or [], config=get_env(ts_tenant=ts_tenant)),
+                    context=run_context,
                     subgraphs=True
             ):
                 async for chunk in handle_stream_event(stream_event):

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/agent_api_server/sso_service/sso_service.py

@@ -58,9 +58,16 @@ class SSOService:
     def __init__(self, sso_config: SSOConfig):
         self.sso_config = sso_config
         self.client_token = None
+        self.sso_client = None
+
+        if not self.sso_config.sso_address:
+            logger.info("SSO address is not configured; skipping SSO client initialization")
+            return
 
-        # Initialize SSOClient
         self.sso_client = SSOClient()
+        if self.sso_config.client_id and self.sso_config.client_secret:
+            return
+
         self.sso_config.client_id, self.sso_config.client_secret = get_sso_client_id_and_secret(
             sso_config.sso_address, ""
         )

{agent_api_server-2.2.1 → agent_api_server-2.2.1a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-api-server"
-version = "2.2.1"
+version = "2.2.1-alpha"
 description = "A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot"
 authors = [
     {name = "Zijie Zhang", email = "zijie.zhang@advantech.com.cn"}
@@ -38,6 +38,7 @@ dependencies = [
     "starlette (>=0.49.3, <0.50.0)",
     "aiohttp (>=3.13.3,<4.0.0)",
     "langchain-mcp-adapters (>=0.2.1,<0.3.0)",
+    "langfuse (>=4.3.1,<5.0.0)",
 ]
 
 [project.urls]