agent-api-server 2.1.7__tar.gz → 2.2.0__tar.gz

agent_api_server-2.2.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.3
+Name: agent-api-server
+Version: 2.2.0
+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
+Author-email: zijie.zhang@advantech.com.cn
+Requires-Python: >=3.11,<3.14
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
+Requires-Dist: aiohttp (>=3.13.3,<4.0.0)
+Requires-Dist: authlib (>=1.6.5)
+Requires-Dist: cryptography (>=45.0.4,<46.0.0)
+Requires-Dist: fastapi (>=0.117.0,<0.121.2)
+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: 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)
+Requires-Dist: llm-sdk (==1.0.1)
+Requires-Dist: model-manage-client (>=0.0.1.8)
+Requires-Dist: nats-py (>=2.11.0,<3.0.0)
+Requires-Dist: psycopg-binary (>=3.2.9,<4.0.0)
+Requires-Dist: psycopg-pool (>=3.2.6,<4.0.0)
+Requires-Dist: pydantic-settings (>=2.9.1,<3.0.0)
+Requires-Dist: redis (>=6.2.0,<7.0.0)
+Requires-Dist: starlette (>=0.49.3,<0.50.0)
+Requires-Dist: tenacity (>=9.1.2,<10.0.0)
+Project-URL: Homepage, https://gitlab.wise-paas.com/openai/agent_api_server
+Project-URL: Repository, https://gitlab.wise-paas.com/openai/agent_api_server
+Description-Content-Type: text/markdown
+
+# agent-api-server
+
+`agent-api-server` is a FastAPI-based API server for LangGraph agents. It exposes REST endpoints for thread, schema, graph, and runtime configuration management, and it serves a built-in web client from `/site`.
+
+## Features
+
+- FastAPI application factory for embedding or standalone deployment
+- LangGraph-oriented API routes under `/api/v1`
+- Built-in static client assets bundled in both sdist and wheel artifacts
+- Redis-backed thread storage and PostgreSQL checkpoint integration
+- Optional integration with config center, SSO, MCP, and model management services
+
+## Requirements
+
+- Python 3.11 to 3.13
+- Redis
+- PostgreSQL
+- Access to all runtime dependencies declared in `pyproject.toml`
+
+## Installation
+
+Install from a package index that provides all required dependencies:
+
+```bash
+pip install agent-api-server
+```
+
+This project depends on `llm-sdk` and `model-manage-client`. If those packages are hosted on a private index in your environment, configure `pip` or Poetry to use that index before installation.
+
+## Configuration
+
+The server reads configuration from environment variables. Common settings include:
+
+```env
+REDIS_URL=redis://localhost:6379/0
+POSTGRES_URL=postgresql://postgres:postgres@localhost:5432/postgres
+MODEL_MANAGER_SERVICE_URL=http://127.0.0.1:10053
+SERVER_PORT=8080
+SERVER_WORKER_AMOUNT=1
+LOG_LEVEL=INFO
+ENABLE_MCP_SERVER=False
+```
+
+See `.env_example` for a more complete example.
+
+## Running the server
+
+Run the application with Uvicorn:
+
+```bash
+uvicorn agent_api_server.service:create_fastapi_app --factory --host 0.0.0.0 --port 8080
+```
+
+After startup:
+
+- API root: `http://127.0.0.1:8080/api/v1`
+- OpenAPI docs: `http://127.0.0.1:8080/docs`
+- Built-in client: `http://127.0.0.1:8080/site`
+
+## Build
+
+Build source and wheel distributions with Poetry:
+
+```bash
+poetry build
+```
+
+## Repository
+
+Source repository: <https://gitlab.wise-paas.com/openai/agent_api_server>
+

agent_api_server-2.2.0/README.md

@@ -0,0 +1,70 @@
+# agent-api-server
+
+`agent-api-server` is a FastAPI-based API server for LangGraph agents. It exposes REST endpoints for thread, schema, graph, and runtime configuration management, and it serves a built-in web client from `/site`.
+
+## Features
+
+- FastAPI application factory for embedding or standalone deployment
+- LangGraph-oriented API routes under `/api/v1`
+- Built-in static client assets bundled in both sdist and wheel artifacts
+- Redis-backed thread storage and PostgreSQL checkpoint integration
+- Optional integration with config center, SSO, MCP, and model management services
+
+## Requirements
+
+- Python 3.11 to 3.13
+- Redis
+- PostgreSQL
+- Access to all runtime dependencies declared in `pyproject.toml`
+
+## Installation
+
+Install from a package index that provides all required dependencies:
+
+```bash
+pip install agent-api-server
+```
+
+This project depends on `llm-sdk` and `model-manage-client`. If those packages are hosted on a private index in your environment, configure `pip` or Poetry to use that index before installation.
+
+## Configuration
+
+The server reads configuration from environment variables. Common settings include:
+
+```env
+REDIS_URL=redis://localhost:6379/0
+POSTGRES_URL=postgresql://postgres:postgres@localhost:5432/postgres
+MODEL_MANAGER_SERVICE_URL=http://127.0.0.1:10053
+SERVER_PORT=8080
+SERVER_WORKER_AMOUNT=1
+LOG_LEVEL=INFO
+ENABLE_MCP_SERVER=False
+```
+
+See `.env_example` for a more complete example.
+
+## Running the server
+
+Run the application with Uvicorn:
+
+```bash
+uvicorn agent_api_server.service:create_fastapi_app --factory --host 0.0.0.0 --port 8080
+```
+
+After startup:
+
+- API root: `http://127.0.0.1:8080/api/v1`
+- OpenAPI docs: `http://127.0.0.1:8080/docs`
+- Built-in client: `http://127.0.0.1:8080/site`
+
+## Build
+
+Build source and wheel distributions with Poetry:
+
+```bash
+poetry build
+```
+
+## Repository
+
+Source repository: <https://gitlab.wise-paas.com/openai/agent_api_server>

{agent_api_server-2.1.7 → agent_api_server-2.2.0}/agent_api_server/api/v1/schema.py

@@ -35,8 +35,22 @@ async def get_graph_schema(graph_name: str):
                 actual_type=type(graph_instance).__name__
             )
 
+        input_schema = graph_instance.get_input_jsonschema()
+        if input_schema:
+            if input_schema.get("properties"):
+                input_schema["properties"].pop("messages")
+            if input_schema.get("required"):
+                required_schema = input_schema.get("required")
+
+                real_required_schema = []
+                for _, schema in enumerate(required_schema):
+                    if schema == "messages":
+                        continue
+                    real_required_schema.append(schema)
+                input_schema["required"] = real_required_schema
+
         return JSONResponse(
-            content=graph_instance.get_input_jsonschema(),
+            content=input_schema,
             media_type="application/schema+json",
         )
     except ValueError as ve:

{agent_api_server-2.1.7 → agent_api_server-2.2.0}/agent_api_server/api/v1/thread.py

@@ -276,8 +276,7 @@ async def stream(
         404: {"model": error_response, "description": "Thread not found"},
         408: {"model": error_response, "description": "Request timeout"},
         500: {"model": error_response, "description": "Execution failed"}
-    },
-    deprecated=True
+    }
 )
 async def run_thread(
         thread_id: str,

agent_api_server-2.2.0/agent_api_server/dynamic_llm/model.py

@@ -0,0 +1,43 @@
+from langchain_core.language_models import BaseChatModel
+from langchain_openai import ChatOpenAI
+from llm_sdk.llm import ModelInstance
+from llm_sdk.model_providers.base import ConfigType
+from pydantic import SecretStr
+
+from agent_api_server.dynamic_llm.dynamic_llm import DynamicLLM
+from agent_api_server.schema.context import Context
+
+def get_init_model()->BaseChatModel:
+    """
+    Get the initial chat model instance.
+    """
+    return ChatOpenAI(
+        model="gpt-4o-2024-05-13",
+        max_tokens=20000,
+        api_key=SecretStr("xxx")
+    )
+
+def get_chat_model_instance(context: Context)-> ModelInstance:
+    """"
+    Get the chat model instance for the given context.
+    """
+
+    dynamic_llm = DynamicLLM(tool_name="default",config_type=ConfigType.CHAT,use_sys_llm=context.use_system_llm)
+
+    llm_config = {
+        "agent_id":context.graph_name,
+        "ts_tenant":context.ts_tenant,
+        "provider":context.config.get(dynamic_llm._get_config_key("PROVIDER", context.ts_tenant)),
+        "model": context.config.get(dynamic_llm._get_config_key("MODEL", context.ts_tenant)),
+        "credentials": context.config.get(dynamic_llm._get_config_key("CREDENTIALS", context.ts_tenant)),
+    }
+    with dynamic_llm._get_model_instance(llm_config,config={}) as model_instance:
+        return model_instance
+
+
+def get_model_credentials(context: Context)-> dict:
+    """
+    Get the model credentials for the given context.
+    """
+    model_instance = get_chat_model_instance(context)
+    return model_instance.unified_credential()

{agent_api_server-2.1.7 → agent_api_server-2.2.0}/agent_api_server/log/formatters.py

@@ -90,7 +90,7 @@ class ColorFormatter(logging.Formatter):
 
         log_template = (
             "{timestamp_color}{timestamp}{reset} "
-            "[{level_color}{levelname:8}{reset}] "
+            "[{level_color}{levelname}{reset}] "
             "{message} "
             "[{module_color}{module}{reset}] "
             "thread_name={thread_color}{thread}{reset}"

{agent_api_server-2.1.7 → agent_api_server-2.2.0}/agent_api_server/mcp_convert/mcp_convert.py

@@ -1,18 +1,17 @@
-import os
 import inspect
 import logging
 import json
 from typing import Dict, Any, Optional, List, Callable, Awaitable
 from functools import wraps, partial
 from datetime import datetime
-from langfuse import propagate_attributes
-from langfuse.langchain import CallbackHandler
-from agent_api_server.shared.decode_token import decode_jwt
+
 from langgraph.config import get_stream_writer
 from langgraph.graph.state import CompiledStateGraph
-from fastmcp import FastMCP, Context
+from fastmcp import FastMCP,Context
 from mcp import types
 from mcp.types import RequestParams, CallToolResult, TextContent
+
+from agent_api_server.schema.context import Context as RuntimeContext
 from agent_api_server.shared.message import handle_stream_event
 from agent_api_server.shared.util_func import load_graph_config, load_graph, get_env
 
@@ -100,12 +99,15 @@ async def _execute_graph_tool(
         Execution result dict
     """
     ctx = Context(fastmcp=mcp)
+
     from fastmcp.server.dependencies import get_http_request
     request = get_http_request()
 
-    use_sys_llm = request.headers.get("UseSysLLM", "")
+    use_sys_llm = request.headers.get("UseSysLLM", None)
     ts_tenant = request.headers.get("TSTenant", "")
     ei_token = request.headers.get("Authorization", "")
+    if ei_token.startswith("Bearer "):
+        ei_token = ei_token.removeprefix("Bearer ")
     thread_id = request.headers.get('thread_id', '')
     start_time = datetime.now()
 
@@ -113,6 +115,20 @@ async def _execute_graph_tool(
 
     # Validate input
     schema = graph_instance.get_input_jsonschema()
+    if schema:
+        if schema.get("properties"):
+            if schema["properties"].get("messages"):
+                schema["properties"].pop("messages")
+                if schema.get("required"):
+                    required_schema = schema.get("required")
+
+                    real_required_schema = []
+                    for _, s in enumerate(required_schema):
+                        if s == "messages":
+                            continue
+                        real_required_schema.append(s)
+                    schema["required"] = real_required_schema
+
     input_dict = {}
     validation_errors = []
 
@@ -139,19 +155,6 @@ async def _execute_graph_tool(
         thread_id = ctx.session_id
         logger.info(f"execute graph {graph_name} with session id {ctx.session_id}")
 
-    user_id = None
-    if ei_token:
-        try:
-            header, payload, user_info = decode_jwt(ei_token)
-            if user_info and 'id' in user_info:
-                user_id = user_info['id']
-                logger.info(f"Extracted user_id from token: {user_id}")
-            else:
-                logger.warning("No user_id found in JWT token")
-        except Exception as e:
-            logger.warning(f"Failed to decode JWT token: {str(e)}")
-
-    # Build configurable parameters
     configurable_params = {
         "use_sys_llm": use_sys_llm,
         "thread_id": thread_id,
@@ -166,53 +169,28 @@ async def _execute_graph_tool(
             **configurable_params
         }
 
-    logger.info(f"finally configurable parameter is {configurable_params}")
-
-    # Configure Langfuse callbacks if available
-    langfuse_keys = [
-        os.getenv("LANGFUSE_SECRET_KEY"),
-        os.getenv("LANGFUSE_PUBLIC_KEY"),
-        os.getenv("LANGFUSE_BASE_URL")
-    ]
-
-    callbacks_config = {}
-    if all(langfuse_keys):
-        langfuse_handler = CallbackHandler()
-        callbacks_config = {"callbacks": [langfuse_handler], "run_name": f"{graph_name}_MCP_Call"}
-
     chunks = []
-    config = {"configurable": configurable_params, **callbacks_config}
     try:
-        async def process_stream():
-            if user_id:
-                logger.info(f"execute graph {graph_name} with user_id: {user_id}")
-                with propagate_attributes(session_id=thread_id, user_id=user_id, trace_name=f"{graph_name}_MCP_Call"):
-                    async for stream_event in graph_instance.astream(
-                            input_dict,
-                            config=config,
-                            stream_mode=["updates"],
-                            subgraphs=True
-                    ):
-                        async for chunk in handle_stream_event(stream_event):
-                            yield chunk
-
-            else:
-                logger.info(f"execute graph {graph_name} without user_id")
-                with propagate_attributes(session_id=thread_id, trace_name=f"{graph_name}_MCP_Call"):
-                    async for stream_event in graph_instance.astream(
-                            input_dict,
-                            config=config,
-                            stream_mode=["updates"],
-                            subgraphs=True
-                    ):
-                        async for chunk in handle_stream_event(stream_event):
-                            yield chunk
-
-
-        async for chunk in process_stream():
-            ctx.request_context.meta = RequestParams.Meta(progressToken=ctx.request_id)
-            await ctx.report_progress(message=chunk, progress=len(chunks))
-            chunks.append(chunk)
+        async for stream_event in graph_instance.astream(
+                input_dict,
+                config={
+                    "configurable": configurable_params
+                },
+                context=RuntimeContext(
+                    use_system_llm=configurable_params.get("use_sys_llm"),
+                    ts_tenant=configurable_params.get("TSTenant"),
+                    ei_token=configurable_params.get("EIToken"),
+                    input=input_dict,
+                    config=configurable_params,
+                    graph_name=configurable_params.get("graph_name"),
+                ),
+                stream_mode=["updates"],
+                subgraphs=True
+        ):
+            async for chunk in handle_stream_event(stream_event):
+                ctx.request_context.meta = RequestParams.Meta(progressToken=ctx.request_id)
+                await ctx.report_progress(message=chunk, progress=len(chunks))
+                chunks.append(chunk)
 
         if not chunks:
             raise ValueError("No response from graph execution")
@@ -251,6 +229,20 @@ def create_tool_from_schema(
         func_doc: str = "",
         implementation: Optional[Callable[..., Awaitable[Dict[str, Any]]]] = None
 ) -> Callable[..., Awaitable[Dict[str, Any]]]:
+    if schema:
+        if schema.get("properties"):
+            if schema["properties"].get("messages"):
+                schema["properties"].pop("messages")
+                if schema.get("required"):
+                    required_schema = schema.get("required")
+
+                    real_required_schema = []
+                    for _, s in enumerate(required_schema):
+                        if s == "messages":
+                            continue
+                        real_required_schema.append(s)
+                    schema["required"] = real_required_schema
+
     properties = schema.get("properties", {})
     required = schema.get("required", [])
     type_map = {

agent_api_server-2.2.0/agent_api_server/mcp_interceptor/mcp_intecerpter.py

@@ -0,0 +1,20 @@
+from langchain_mcp_adapters.interceptors import MCPToolCallRequest
+
+async def inject_authorization(
+    request: MCPToolCallRequest,
+    handler,
+):
+    """Inject user credentials into MCP tool calls."""
+    runtime = request.runtime
+    authorization = runtime.context.ei_token
+    tenant_id = runtime.context.ts_tenant
+
+    if request.headers:
+        headers = {**request.headers, "TSTenant": tenant_id, "Authorization": f"Bearer {authorization}"}
+    else:
+        headers = {"TSTenant": tenant_id, "Authorization": f"Bearer {authorization}"}
+    # Add user context to tool arguments
+    modified_request = request.override(
+        headers={**headers}
+    )
+    return await handler(modified_request)

agent_api_server-2.2.0/agent_api_server/middleware/model.py

@@ -0,0 +1,59 @@
+from langchain_core.messages import HumanMessage
+
+from agent_api_server.middleware.schema import InputState
+from agent_api_server.schema.context import Context
+from agent_api_server.dynamic_llm.model import get_chat_model_instance
+from langchain.agents.middleware import AgentMiddleware, ModelRequest, ModelResponse, wrap_tool_call
+from typing import Callable
+
+class ModelMiddleware(AgentMiddleware[InputState]):
+    state_schema = InputState
+
+    def __init__(self, use_system_llm:bool=False):
+        super().__init__()
+        self.use_system_llm = use_system_llm
+
+    async def abefore_agent(self,state: InputState) -> ModelRequest:
+        human_message = [HumanMessage(content=state["user_input"])]
+        return {
+            "messages": [
+                *state["messages"],
+                *human_message
+            ]
+        }
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelResponse:
+        context: Context = request.runtime.context
+        if context.use_system_llm is None:
+            context.use_system_llm = self.use_system_llm
+
+        model_instance = get_chat_model_instance(context)
+
+        model_settings = request.model_settings.copy()
+        model_settings.pop("cache_control", None)
+
+        return await handler(request.override(model=model_instance, model_settings=model_settings))
+
+class ChangeModel(AgentMiddleware):
+    def __init__(self, use_system_llm: bool = False):
+        super().__init__()
+        self.use_system_llm = use_system_llm
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelResponse:
+        context: Context = request.runtime.context
+        context.use_system_llm = self.use_system_llm
+
+        model_instance = get_chat_model_instance(context)
+
+        model_settings = request.model_settings.copy()
+        model_settings.pop("cache_control", None)
+
+        return await handler(request.override(model=model_instance, model_settings=model_settings))

agent_api_server-2.2.0/agent_api_server/middleware/schema.py

@@ -0,0 +1,6 @@
+from langchain.agents import AgentState
+from typing_extensions import Required
+
+
+class InputState(AgentState):
+    user_input: Required[str]

agent_api_server-2.2.0/agent_api_server/schema/context.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from typing import Optional
+from dataclasses import dataclass
+
+@dataclass
+class Context:
+    ts_tenant: str
+    use_system_llm: Optional[bool] = None
+    input: Optional[dict] = None
+    ei_token: Optional[str] = None
+    graph_name: Optional[str] = None
+    files: Optional[list[dict]] = None
+    config: Optional[dict] = None