licos-agent-runtime 0.1.0__tar.gz

licos_agent_runtime-0.1.0/.gitignore

@@ -0,0 +1,44 @@
+# Rust
+/target/
+**/*.rs.bk
+Cargo.lock
+
+# Node
+node_modules/
+packages/*/dist/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Workspace
+/workspace/
+
+# Test runtime data
+/test/licos-data/
+/test/screenshots/
+/test/vue-app/
+
+# Build
+*.log
+.licos
+
+/tmp
+
+/Docs/hermes-agent
+/Docs/OpenCode
+/Docs/平台API
+
+*.codex-*
+
+project-20260423_130440

licos_agent_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: licos-agent-runtime
+Version: 0.1.0
+Summary: LICOS Python agent runtime for LangGraph/LangChain projects
+Requires-Python: >=3.10
+Requires-Dist: fastapi<1,>=0.121
+Requires-Dist: langchain-openai<2,>=1.2
+Requires-Dist: langchain<2,>=1.2
+Requires-Dist: langgraph-checkpoint-postgres<4,>=3.0
+Requires-Dist: langgraph-checkpoint<5,>=4
+Requires-Dist: langgraph-prebuilt<2,>=1.0
+Requires-Dist: langgraph-sdk<1,>=0.3
+Requires-Dist: langgraph<2,>=1.1
+Requires-Dist: langsmith<1,>=0.4
+Requires-Dist: licos-platform-sdk>=0.1.0
+Requires-Dist: pydantic<3,>=2.12
+Requires-Dist: uvicorn<1,>=0.38

licos_agent_runtime-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "licos-agent-runtime"
+version = "0.1.0"
+description = "LICOS Python agent runtime for LangGraph/LangChain projects"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.121,<1",
+    "uvicorn>=0.38,<1",
+    "pydantic>=2.12,<3",
+    "langchain>=1.2,<2",
+    "langchain-openai>=1.2,<2",
+    "langgraph>=1.1,<2",
+    "langgraph-checkpoint>=4,<5",
+    "langgraph-prebuilt>=1.0,<2",
+    "langgraph-sdk>=0.3,<1",
+    "langgraph-checkpoint-postgres>=3.0,<4",
+    "langsmith>=0.4,<1",
+    "licos-platform-sdk>=0.1.0",
+]
+
+[project.scripts]
+licos-agent-runtime = "licos_agent_runtime.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/licos_agent_runtime"]

licos_agent_runtime-0.1.0/src/licos_agent_runtime/__init__.py

@@ -0,0 +1,18 @@
+"""LICOS agent runtime.
+
+The top-level package intentionally avoids importing FastAPI/LangGraph-heavy
+modules. Import ``create_app`` or ``GraphService`` explicitly when starting a
+runtime process.
+"""
+
+from .context import Context, RuntimeIdentity, new_context, request_context
+from .graph_loader import is_agent_project, is_workflow_project
+
+__all__ = [
+    "Context",
+    "RuntimeIdentity",
+    "is_agent_project",
+    "is_workflow_project",
+    "new_context",
+    "request_context",
+]

licos_agent_runtime-0.1.0/src/licos_agent_runtime/__main__.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+from typing import Any
+
+import uvicorn
+
+from .context import new_context
+from .graph_loader import is_dev_env
+from .logging import setup_logging
+from .service import GraphService
+
+
+def parse_input(input_str: str) -> dict[str, Any]:
+    if not input_str:
+        return {"text": "你好"}
+    try:
+        value = json.loads(input_str)
+    except json.JSONDecodeError:
+        return {"text": input_str}
+    return value if isinstance(value, dict) else {"input": value}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Start LICOS agent runtime")
+    parser.add_argument("-m", "--mode", default="http", choices=["http", "flow", "node", "agent"])
+    parser.add_argument("-n", "--node", default="", help="Node ID for node mode")
+    parser.add_argument("-p", "--port", type=int, default=5000, help="HTTP server port")
+    parser.add_argument("-i", "--input", default="", help="Input JSON string or plain text")
+    parser.add_argument("--host", default="0.0.0.0", help="HTTP bind host")
+    return parser.parse_args()
+
+
+def start_http_server(host: str, port: int) -> None:
+    logger = logging.getLogger(__name__)
+    reload_enabled = is_dev_env()
+    logger.info("Start LICOS agent runtime HTTP server: host=%s port=%s reload=%s", host, port, reload_enabled)
+    uvicorn.run("licos_agent_runtime.app:app", host=host, port=port, reload=reload_enabled, workers=1)
+
+
+def main() -> None:
+    setup_logging()
+    args = parse_args()
+    service = GraphService()
+
+    if args.mode == "http":
+        start_http_server(args.host, args.port)
+    elif args.mode == "flow":
+        payload = parse_input(args.input)
+        result = asyncio.run(service.run(payload))
+        print(json.dumps(result, ensure_ascii=False, indent=2, default=str))
+    elif args.mode == "node":
+        if not args.node:
+            raise SystemExit("--node is required in node mode")
+        payload = parse_input(args.input)
+        result = asyncio.run(service.run_node(args.node, payload))
+        print(json.dumps(result, ensure_ascii=False, indent=2, default=str))
+    elif args.mode == "agent":
+        ctx = new_context(method="agent")
+        payload = parse_input(args.input)
+        for chunk in service.stream(payload, run_config={"configurable": {"session_id": ctx.run_id}}, ctx=ctx):
+            print(chunk)
+
+
+if __name__ == "__main__":
+    main()

licos_agent_runtime-0.1.0/src/licos_agent_runtime/app.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import StreamingResponse
+
+from . import telemetry
+from .context import new_context, request_context
+from .errors import extract_core_stack
+from .graph_loader import is_agent_project
+from .openai import OpenAIChatHandler
+from .service import GraphService
+from .stream_runner import RunOpt, agent_stream_handler, workflow_stream_handler
+
+logger = logging.getLogger(__name__)
+
+HEADER_X_RUN_ID = "x-run-id"
+HEADER_X_WORKFLOW_STREAM_MODE = "x-workflow-stream-mode"
+
+
+def create_app(service: GraphService | None = None) -> FastAPI:
+    runtime_service = service or GraphService()
+    openai_handler = OpenAIChatHandler(runtime_service)
+    app = FastAPI()
+
+    def register_task(run_id: str, task: asyncio.Task) -> None:
+        runtime_service.running_tasks[run_id] = task
+
+    @app.post("/run")
+    async def http_run(request: Request) -> dict[str, Any]:
+        raw_body = await request.body()
+        try:
+            body_text = raw_body.decode("utf-8")
+        except UnicodeDecodeError:
+            body_text = str(raw_body)
+
+        ctx = new_context(method="run", headers=request.headers)
+        request_context.set(ctx)
+        logger.info(
+            "Received /run: run_id=%s query=%s body=%s",
+            ctx.run_id,
+            dict(request.query_params),
+            body_text,
+        )
+
+        try:
+            payload = json.loads(body_text) if body_text else {}
+            return await runtime_service.run_with_timeout(payload, ctx)
+        except json.JSONDecodeError as exc:
+            logger.error("JSON decode error in /run: %s", exc)
+            raise HTTPException(status_code=400, detail=f"Invalid JSON format: {extract_core_stack()}") from exc
+        except asyncio.CancelledError:
+            return {"status": "cancelled", "run_id": ctx.run_id, "message": "Execution was cancelled"}
+        except Exception as exc:
+            error_response = runtime_service.error_classifier.get_error_response(
+                exc,
+                {"node_name": "http_run", "run_id": ctx.run_id},
+            )
+            logger.error("Unexpected error in /run: %s", error_response, exc_info=True)
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "error_code": error_response["error_code"],
+                    "error_message": error_response["error_message"],
+                    "stack_trace": extract_core_stack(),
+                },
+            ) from exc
+        finally:
+            telemetry.flush()
+
+    @app.post("/stream_run")
+    async def http_stream_run(request: Request) -> StreamingResponse:
+        ctx = new_context(method="stream_run", headers=request.headers)
+        request_context.set(ctx)
+        workflow_stream_mode = request.headers.get(HEADER_X_WORKFLOW_STREAM_MODE, "").lower()
+        workflow_debug = workflow_stream_mode == "debug"
+        stream_mode = None if workflow_debug else (workflow_stream_mode or None)
+        run_opt = RunOpt(workflow_debug=workflow_debug, stream_mode=stream_mode, platform_stream_protocol=True)
+        raw_body = await request.body()
+        try:
+            body_text = raw_body.decode("utf-8")
+        except UnicodeDecodeError:
+            body_text = str(raw_body)
+        logger.info(
+            "Received /stream_run: run_id=%s is_agent_project=%s query=%s body=%s",
+            ctx.run_id,
+            is_agent_project(),
+            dict(request.query_params),
+            body_text,
+        )
+
+        try:
+            payload = json.loads(body_text) if body_text else {}
+        except json.JSONDecodeError as exc:
+            logger.error("JSON decode error in /stream_run: %s", exc)
+            raise HTTPException(status_code=400, detail=f"Invalid JSON format: {extract_core_stack()}") from exc
+
+        if is_agent_project():
+            stream_generator = agent_stream_handler(
+                payload=payload,
+                ctx=ctx,
+                run_id=ctx.run_id,
+                stream_sse_func=runtime_service.stream_sse,
+                sse_event_func=runtime_service._sse_event,
+                error_classifier=runtime_service.error_classifier,
+                register_task_func=register_task,
+                run_opt=run_opt,
+            )
+        else:
+            stream_generator = workflow_stream_handler(
+                payload=payload,
+                ctx=ctx,
+                run_id=ctx.run_id,
+                stream_sse_func=runtime_service.stream_sse,
+                sse_event_func=runtime_service._sse_event,
+                error_classifier=runtime_service.error_classifier,
+                register_task_func=register_task,
+                run_opt=run_opt,
+            )
+
+        return StreamingResponse(stream_generator, media_type="text/event-stream")
+
+    @app.post("/cancel/{run_id}")
+    async def http_cancel(run_id: str, request: Request) -> dict[str, Any]:
+        ctx = new_context(method="cancel", headers=request.headers)
+        request_context.set(ctx)
+        return runtime_service.cancel_run(run_id, ctx)
+
+    @app.post("/node_run/{node_id}")
+    async def http_node_run(node_id: str, request: Request) -> Any:
+        raw_body = await request.body()
+        try:
+            body_text = raw_body.decode("utf-8")
+        except UnicodeDecodeError:
+            body_text = str(raw_body)
+        ctx = new_context(method="node_run", headers=request.headers)
+        request_context.set(ctx)
+        try:
+            payload = json.loads(body_text) if body_text else {}
+            return await runtime_service.run_node(node_id, payload, ctx)
+        except json.JSONDecodeError as exc:
+            raise HTTPException(status_code=400, detail=f"Invalid JSON format: {extract_core_stack()}") from exc
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except Exception as exc:
+            error_response = runtime_service.error_classifier.get_error_response(exc, {"node_name": node_id})
+            logger.error("Unexpected error in /node_run/%s: %s", node_id, error_response, exc_info=True)
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "error_code": error_response["error_code"],
+                    "error_message": error_response["error_message"],
+                    "stack_trace": extract_core_stack(),
+                },
+            ) from exc
+        finally:
+            telemetry.flush()
+
+    @app.post("/v1/chat/completions")
+    async def openai_chat_completions(request: Request) -> Any:
+        ctx = new_context(method="openai_chat", headers=request.headers)
+        request_context.set(ctx)
+        try:
+            payload = await request.json()
+            return await openai_handler.handle(payload, ctx)
+        except json.JSONDecodeError as exc:
+            raise HTTPException(status_code=400, detail="Invalid JSON format") from exc
+        finally:
+            telemetry.flush()
+
+    @app.get("/health")
+    async def health_check() -> dict[str, str]:
+        return {"status": "ok", "message": "Service is running"}
+
+    @app.get("/graph_parameter")
+    async def http_graph_inout_parameter(request: Request) -> dict[str, Any]:
+        del request
+        return runtime_service.graph_inout_schema()
+
+    return app
+
+
+app = create_app()

licos_agent_runtime-0.1.0/src/licos_agent_runtime/context.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import os
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+from uuid import uuid4
+
+
+def _env(name: str) -> str | None:
+    value = os.environ.get(name)
+    if value is None:
+        return None
+    value = value.strip()
+    return value or None
+
+
+def _headers_to_dict(headers: Mapping[str, Any] | None) -> dict[str, str]:
+    if headers is None:
+        return {}
+    return {str(key).lower(): str(value) for key, value in headers.items()}
+
+
+@dataclass(slots=True)
+class RuntimeIdentity:
+    user_id: str | None = None
+    workspace_id: str | None = None
+    project_id: str | None = None
+    project_type: str | None = None
+    instance_id: str | None = None
+    profile_id: str | None = None
+    user_token: str | None = None
+
+    @classmethod
+    def from_env(cls) -> "RuntimeIdentity":
+        return cls(
+            user_id=_env("AGENT_USER_ID") or _env("LICOS_USER_ID"),
+            workspace_id=_env("AGENT_WORKSPACE_ID") or _env("LICOS_WORKSPACE_ID"),
+            project_id=_env("AGENT_PROJECT_ID") or _env("LICOS_PROJECT_ID"),
+            project_type=_env("AGENT_PROJECT_TYPE") or _env("LICOS_PROJECT_TYPE"),
+            instance_id=_env("INSTANCE_ID") or _env("LICOS_INSTANCE_ID"),
+            profile_id=_env("AGENT_PROFILE_ID") or _env("LICOS_AGENT_PROFILE_ID"),
+            user_token=_env("LICOS_USER_TOKEN"),
+        )
+
+    def to_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {}
+        if self.user_id:
+            headers["X-User-Id"] = self.user_id
+        if self.workspace_id:
+            headers["X-Workspace-Id"] = self.workspace_id
+        if self.project_id:
+            headers["X-Project-Id"] = self.project_id
+        if self.user_token:
+            headers["Authorization"] = f"Bearer {self.user_token}"
+        return headers
+
+
+@dataclass(slots=True)
+class Context:
+    method: str
+    run_id: str = field(default_factory=lambda: uuid4().hex)
+    headers: dict[str, str] = field(default_factory=dict)
+    identity: RuntimeIdentity = field(default_factory=RuntimeIdentity.from_env)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def header(self, name: str, default: str | None = None) -> str | None:
+        return self.headers.get(name.lower(), default)
+
+    def with_run_id(self, run_id: str | None) -> "Context":
+        if run_id and run_id.strip():
+            self.run_id = run_id.strip()
+        return self
+
+
+request_context: ContextVar[Context | None] = ContextVar(
+    "licos_agent_request_context",
+    default=None,
+)
+
+
+def new_context(
+    method: str = "run",
+    headers: Mapping[str, Any] | None = None,
+    **metadata: Any,
+) -> Context:
+    ctx = Context(method=method, headers=_headers_to_dict(headers), metadata=dict(metadata))
+    upstream_run_id = ctx.header("x-run-id")
+    if upstream_run_id:
+        ctx.run_id = upstream_run_id
+    return ctx

licos_agent_runtime-0.1.0/src/licos_agent_runtime/errors.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import traceback
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class ErrorCategory(str, Enum):
+    CANCELLED = "cancelled"
+    TIMEOUT = "timeout"
+    VALIDATION = "validation"
+    RUNTIME = "runtime"
+    INTERNAL = "internal"
+
+
+@dataclass(slots=True)
+class ClassifiedError:
+    code: str
+    message: str
+    category: ErrorCategory
+
+
+class ErrorClassifier:
+    def classify(self, error: BaseException, context: dict[str, Any] | None = None) -> ClassifiedError:
+        del context
+        name = error.__class__.__name__
+        if name == "CancelledError":
+            return ClassifiedError("RUN_CANCELLED", str(error) or "Execution cancelled", ErrorCategory.CANCELLED)
+        if name == "TimeoutError":
+            return ClassifiedError("RUN_TIMEOUT", str(error) or "Execution timeout", ErrorCategory.TIMEOUT)
+        if isinstance(error, (KeyError, ValueError, TypeError)):
+            return ClassifiedError("PARAM_INVALID", str(error), ErrorCategory.VALIDATION)
+        return ClassifiedError("RUNTIME_ERROR", str(error) or name, ErrorCategory.RUNTIME)
+
+    def get_error_response(
+        self,
+        error: BaseException,
+        context: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        classified = self.classify(error, context)
+        return {
+            "error_code": classified.code,
+            "error_message": classified.message,
+            "category": classified.category.value,
+        }
+
+
+def extract_core_stack() -> str:
+    return "".join(traceback.format_exc())