licos-agent-runtime 0.2.2__tar.gz → 0.2.6__tar.gz

{licos_agent_runtime-0.2.2 → licos_agent_runtime-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-agent-runtime
-Version: 0.2.2
+Version: 0.2.6
 Summary: LICOS Python agent runtime for LangGraph/LangChain projects
 Requires-Python: >=3.10
 Requires-Dist: fastapi<1,>=0.121
@@ -12,6 +12,6 @@ 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.2.0
+Requires-Dist: licos-platform-sdk>=0.2.2
 Requires-Dist: pydantic<3,>=2.12
 Requires-Dist: uvicorn<1,>=0.38

{licos_agent_runtime-0.2.2 → licos_agent_runtime-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-agent-runtime"
-version = "0.2.2"
+version = "0.2.6"
 description = "LICOS Python agent runtime for LangGraph/LangChain projects"
 requires-python = ">=3.10"
 dependencies = [
@@ -19,7 +19,7 @@ dependencies = [
     "langgraph-sdk>=0.3,<1",
     "langgraph-checkpoint-postgres>=3.0,<4",
     "langsmith>=0.4,<1",
-    "licos-platform-sdk>=0.2.0",
+    "licos-platform-sdk>=0.2.2",
 ]
 
 [project.scripts]

licos_agent_runtime-0.2.6/src/licos_agent_runtime/agent_canvas.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .agent_config import AGENT_CONFIG_PATH
+
+
+def agent_canvas_data() -> dict[str, Any]:
+    nodes: list[dict[str, Any]] = [
+        {
+            "id": "__start__",
+            "type": "start",
+            "definition": {
+                "info": {
+                    "title": "开始",
+                    "description": "",
+                }
+            },
+            "script": {},
+        },
+        {
+            "id": "agent",
+            "type": "agent",
+            "definition": {
+                "info": {
+                    "title": "agent节点",
+                    "description": "",
+                    "dependencies": {
+                        "llm_config": [AGENT_CONFIG_PATH],
+                    },
+                }
+            },
+            "script": {},
+        },
+        {
+            "id": "__end__",
+            "type": "end",
+            "definition": {
+                "info": {
+                    "title": "结束",
+                    "description": "",
+                }
+            },
+            "script": {},
+        },
+    ]
+    return {
+        "canvas_data": "",
+        "canvas_version": "",
+        "data": "\n" + json.dumps({"nodes": nodes}, ensure_ascii=False, indent=4),
+    }
+
+
+def agent_canvas_response() -> dict[str, Any]:
+    return {
+        "code": 0,
+        "data": agent_canvas_data(),
+        "msg": "",
+    }

licos_agent_runtime-0.2.6/src/licos_agent_runtime/agent_config.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .graph_loader import project_root
+
+AGENT_CONFIG_RELATIVE_PATH = Path("config") / "agent_llm_config.json"
+AGENT_CONFIG_PATH = AGENT_CONFIG_RELATIVE_PATH.as_posix()
+
+
+def _empty_payload(*, exists: bool = False) -> dict[str, Any]:
+    return {
+        "path": AGENT_CONFIG_PATH,
+        "exists": exists,
+        "config": {},
+        "sp": "",
+        "up": "",
+        "tools": [],
+        "raw": {},
+    }
+
+
+def _text(value: Any) -> str:
+    if value is None:
+        return ""
+    return value if isinstance(value, str) else str(value)
+
+
+def _tools(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+
+    result: list[str] = []
+    seen: set[str] = set()
+    for item in value:
+        name = _text(item).strip()
+        if not name or name in seen:
+            continue
+        result.append(name)
+        seen.add(name)
+    return result
+
+
+def read_agent_config(root: Path | None = None) -> dict[str, Any]:
+    """Read Coze-style agent config metadata without failing runtime APIs."""
+    base = root or project_root()
+    path = base / AGENT_CONFIG_RELATIVE_PATH
+    if not path.is_file():
+        return _empty_payload(exists=False)
+
+    payload = _empty_payload(exists=True)
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        payload["error"] = str(exc)
+        return payload
+
+    if not isinstance(raw, dict):
+        payload["error"] = "agent config must be a JSON object"
+        return payload
+
+    config = raw.get("config")
+    payload["raw"] = raw
+    payload["config"] = config if isinstance(config, dict) else {}
+    payload["sp"] = _text(raw.get("sp"))
+    payload["up"] = _text(raw.get("up"))
+    payload["tools"] = _tools(raw.get("tools"))
+    return payload

{licos_agent_runtime-0.2.2 → licos_agent_runtime-0.2.6}/src/licos_agent_runtime/app.py

@@ -78,7 +78,7 @@ def create_app(service: GraphService | None = None) -> FastAPI:
         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)
+        stream_mode = "debug" if workflow_debug else "updates"
         run_opt = RunOpt(workflow_debug=workflow_debug, stream_mode=stream_mode, platform_stream_protocol=True)
         raw_body = await request.body()
         try:
@@ -181,6 +181,43 @@ def create_app(service: GraphService | None = None) -> FastAPI:
         del request
         return runtime_service.graph_inout_schema()
 
+    @app.get("/agent/config")
+    async def http_agent_config(request: Request) -> dict[str, Any]:
+        del request
+        return runtime_service.agent_config_info()
+
+    @app.get("/agent/canvas")
+    async def http_agent_canvas_get(request: Request) -> dict[str, Any]:
+        del request
+        return runtime_service.agent_canvas()
+
+    @app.post("/agent/canvas")
+    async def http_agent_canvas_post(request: Request) -> dict[str, Any]:
+        del request
+        return runtime_service.agent_canvas()
+
+    @app.post("/v1/api/project/{project_id}/agent/canvas")
+    async def http_agent_canvas_coze(project_id: str, request: Request) -> dict[str, Any]:
+        del project_id, request
+        return runtime_service.agent_canvas()
+
+    @app.post("/agent/canvas_submit")
+    async def http_agent_canvas_submit(request: Request) -> dict[str, Any]:
+        try:
+            payload = await request.json()
+            if not isinstance(payload, dict):
+                raise ValueError("request body must be an object")
+            return runtime_service.agent_canvas_submit(payload)
+        except json.JSONDecodeError as exc:
+            raise HTTPException(status_code=400, detail="Invalid JSON format") from exc
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @app.post("/v1/api/project/{project_id}/agent/canvas_submit")
+    async def http_agent_canvas_submit_coze(project_id: str, request: Request) -> dict[str, Any]:
+        del project_id
+        return await http_agent_canvas_submit(request)
+
     return app
 
 

licos_agent_runtime-0.2.6/src/licos_agent_runtime/attachments.py

@@ -0,0 +1,352 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path, PurePosixPath
+import tempfile
+from typing import Any
+from urllib.parse import unquote, urlparse
+from urllib.request import Request, urlopen
+
+
+DEFAULT_PROJECT_PATH = "/workspace/projects"
+DEFAULT_ATTACHMENT_DIR = "assets"
+
+
+def project_path() -> Path:
+    return Path(os.environ.get("LICOS_PROJECT_PATH") or DEFAULT_PROJECT_PATH).resolve()
+
+
+def attachment_dir(project_root: Path | None = None) -> Path:
+    root = project_root or project_path()
+    configured = os.environ.get("LICOS_AGENT_ATTACHMENT_DIR") or DEFAULT_ATTACHMENT_DIR
+    relative = PurePosixPath(str(configured).replace("\\", "/"))
+    if relative.is_absolute() or any(part == ".." for part in relative.parts):
+        relative = PurePosixPath(DEFAULT_ATTACHMENT_DIR)
+    return root.joinpath(*relative.parts)
+
+
+def extract_upload_file(item: Any) -> dict[str, Any] | None:
+    if not isinstance(item, dict):
+        return None
+
+    upload_file: Any = None
+    if item.get("type") == "upload_file":
+        content = item.get("content")
+        if isinstance(content, dict):
+            upload_file = content.get("upload_file") or content.get("file")
+        elif isinstance(content, str):
+            upload_file = {"url": content}
+    elif "upload_file" in item:
+        upload_file = item.get("upload_file")
+
+    if not isinstance(upload_file, dict):
+        return None
+    return dict(upload_file)
+
+
+def materialize_upload_file(upload_file: dict[str, Any], index: int = 0) -> dict[str, Any]:
+    root = project_path()
+    assets = attachment_dir(root)
+    file_name = _safe_file_name(
+        upload_file.get("file_name")
+        or upload_file.get("name")
+        or _file_name_from_url(upload_file.get("url"))
+        or f"attachment-{index + 1}"
+    )
+    dest = (assets / file_name).resolve()
+    record = _attachment_record(upload_file, root, dest, file_name)
+
+    try:
+        _ensure_inside(root, dest)
+        assets.mkdir(parents=True, exist_ok=True)
+
+        url = upload_file.get("url")
+        if isinstance(url, str) and url.strip():
+            content_type = _download_to_file(url.strip(), dest)
+            record.update(_saved_record(root, dest))
+            if content_type:
+                record["mime_type"] = content_type
+            record["file_type"] = infer_file_type(record)
+            return record
+
+        record["status"] = "failed"
+        record["error"] = "missing upload_file.url"
+        record["file_type"] = infer_file_type(record)
+        return record
+    except Exception as exc:
+        record["status"] = "failed"
+        record["error"] = str(exc) or exc.__class__.__name__
+        record["file_type"] = infer_file_type(record)
+        return record
+
+
+def materialize_upload_files(upload_files: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [materialize_upload_file(upload_file, index) for index, upload_file in enumerate(upload_files)]
+
+
+def format_attachment_manifest(attachments: list[dict[str, Any]]) -> str:
+    if not attachments:
+        return ""
+    lines = ["Attachments:"]
+    for attachment in attachments:
+        file_name = attachment.get("file_name") or ""
+        file_path = attachment.get("file_path") or ""
+        status = attachment.get("status") or ""
+        line = f"- file_name: {file_name}"
+        if file_path:
+            line += f", file_path: {file_path}"
+        if status and status != "saved":
+            line += f", status: {status}"
+        if attachment.get("error"):
+            line += f", error: {attachment['error']}"
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def content_parts_for_attachment(attachment: dict[str, Any]) -> list[dict[str, Any]]:
+    url = str(attachment.get("url") or attachment.get("source_url") or "")
+    file_name = str(attachment.get("file_name") or "")
+    file_path = str(attachment.get("file_path") or "")
+    file_type = str(attachment.get("file_type") or infer_file_type(attachment))
+    mime_type = str(attachment.get("mime_type") or "")
+
+    if file_type == "image" and url:
+        return [
+            {"type": "text", "text": url},
+            {"type": "image_url", "image_url": {"url": url}},
+        ]
+    if file_type == "video" and url:
+        video_url: dict[str, Any] = {"url": url}
+        if mime_type:
+            video_url["media_type"] = mime_type
+        return [
+            {"type": "text", "text": url},
+            {"type": "video_url", "video_url": video_url},
+        ]
+    if file_type == "audio" and url:
+        return [{"type": "text", "text": f"audio url: {url}"}]
+
+    text = f"file name:{file_name}, url: {url}"
+    if file_path:
+        text += f"\nlocal file path: {file_path}"
+    extracted = extract_text_preview(attachment)
+    if extracted:
+        text += f"\n\nFile Content:\n{extracted}"
+    return [{"type": "text", "text": text}]
+
+
+def infer_file_type(attachment: dict[str, Any]) -> str:
+    mime_type = str(attachment.get("mime_type") or "").split(";")[0].strip().lower()
+    if mime_type:
+        top = mime_type.split("/", 1)[0]
+        if top in {"image", "video", "audio"}:
+            return top
+        if top == "text" or mime_type in {
+            "application/json",
+            "application/xml",
+            "application/pdf",
+            "application/msword",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-powerpoint",
+            "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        }:
+            return "document"
+
+    for value in (attachment.get("file_name"), attachment.get("url"), attachment.get("source_url")):
+        ext = _extension(value)
+        if not ext:
+            continue
+        if ext in IMAGE_EXTENSIONS:
+            return "image"
+        if ext in VIDEO_EXTENSIONS:
+            return "video"
+        if ext in AUDIO_EXTENSIONS:
+            return "audio"
+        if ext in DOCUMENT_EXTENSIONS:
+            return "document"
+    return "default"
+
+
+def extract_text_preview(attachment: dict[str, Any]) -> str:
+    path = attachment.get("local_path")
+    if not isinstance(path, str) or not path:
+        return ""
+    suffix = _extension(path)
+    if suffix not in TEXT_PREVIEW_EXTENSIONS:
+        return ""
+    try:
+        data = Path(path).read_bytes()
+    except OSError:
+        return ""
+    if len(data) > TEXT_PREVIEW_MAX_BYTES:
+        data = data[:TEXT_PREVIEW_MAX_BYTES]
+    return data.decode("utf-8", errors="replace")
+
+
+def _attachment_record(upload_file: dict[str, Any], root: Path, dest: Path, file_name: str) -> dict[str, Any]:
+    source_file_name = upload_file.get("file_name") or upload_file.get("name")
+    record: dict[str, Any] = {
+        "type": "upload_file",
+        "file_name": file_name,
+        "file_path": _relative_posix(root, dest),
+        "local_path": str(dest),
+        "status": "pending",
+    }
+    if source_file_name and str(source_file_name) != file_name:
+        record["original_file_name"] = str(source_file_name)
+    for source_key, target_key in (
+        ("url", "url"),
+        ("mime_type", "mime_type"),
+        ("content_type", "mime_type"),
+        ("size", "size"),
+    ):
+        value = upload_file.get(source_key)
+        if value not in (None, "") and target_key not in record:
+            record[target_key] = value
+    record["file_type"] = infer_file_type(record)
+    return record
+
+
+def _saved_record(root: Path, dest: Path) -> dict[str, Any]:
+    stat = dest.stat()
+    return {
+        "file_path": _relative_posix(root, dest),
+        "local_path": str(dest),
+        "size": stat.st_size,
+        "status": "saved",
+    }
+
+
+def _download_to_file(url: str, dest: Path) -> str:
+    parsed = urlparse(url)
+    if parsed.scheme not in {"http", "https"}:
+        raise ValueError(f"unsupported upload_file.url scheme: {parsed.scheme or '<empty>'}")
+
+    timeout = _float_env("LICOS_AGENT_ATTACHMENT_TIMEOUT_SECONDS", 30.0)
+    max_bytes = int(_float_env("LICOS_AGENT_ATTACHMENT_MAX_BYTES", 100 * 1024 * 1024))
+    request = Request(url, headers={"User-Agent": "licos-agent-runtime"})
+
+    tmp_path: Path | None = None
+    try:
+        content_type = ""
+        with urlopen(request, timeout=timeout) as response:
+            content_type = str(response.headers.get("Content-Type") or "").split(";", 1)[0].strip()
+            content_length = response.headers.get("Content-Length")
+            if content_length and int(content_length) > max_bytes:
+                raise ValueError(f"attachment exceeds max size: {content_length} > {max_bytes}")
+
+            with tempfile.NamedTemporaryFile(delete=False, dir=str(dest.parent), prefix=f".{dest.name}.") as tmp:
+                tmp_path = Path(tmp.name)
+                total = 0
+                while True:
+                    chunk = response.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    total += len(chunk)
+                    if total > max_bytes:
+                        raise ValueError(f"attachment exceeds max size: {total} > {max_bytes}")
+                    tmp.write(chunk)
+
+        if tmp_path is None:
+            raise ValueError("failed to create temporary attachment file")
+        os.replace(tmp_path, dest)
+        return content_type
+    except Exception:
+        if tmp_path is not None and tmp_path.exists():
+            try:
+                tmp_path.unlink()
+            except OSError:
+                pass
+        raise
+
+
+def _ensure_inside(root: Path, path: Path) -> None:
+    root_resolved = root.resolve()
+    path_resolved = path.resolve()
+    if path_resolved == root_resolved:
+        return
+    if root_resolved not in path_resolved.parents:
+        raise ValueError(f"path is outside project root: {path}")
+
+
+def _safe_file_name(value: Any) -> str:
+    raw = str(value or "").replace("\\", "/")
+    name = PurePosixPath(raw).name.strip()
+    if not name:
+        name = "attachment"
+    sanitized = "".join("_" if char in {'/', '\\', ':', '*', '?', '"', '<', '>', '|'} or ord(char) < 32 else char for char in name)
+    sanitized = sanitized.strip(" .")
+    return sanitized or "attachment"
+
+
+def _file_name_from_url(value: Any) -> str | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    parsed = urlparse(value)
+    name = PurePosixPath(unquote(parsed.path)).name
+    return name or None
+
+
+def _extension(value: Any) -> str:
+    if not isinstance(value, str) or not value.strip():
+        return ""
+    parsed = urlparse(value)
+    path = unquote(parsed.path or value)
+    suffix = PurePosixPath(path).suffix.lower().lstrip(".")
+    return suffix
+
+
+def _relative_posix(root: Path, path: Path) -> str:
+    try:
+        relative = path.resolve().relative_to(root.resolve())
+    except ValueError:
+        return path.name
+    return relative.as_posix()
+
+
+def _float_env(name: str, default: float) -> float:
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    try:
+        return float(value)
+    except ValueError:
+        return default
+
+
+IMAGE_EXTENSIONS = {
+    "apng",
+    "avif",
+    "bmp",
+    "gif",
+    "heic",
+    "ico",
+    "jpg",
+    "jpeg",
+    "png",
+    "svg",
+    "tiff",
+    "webp",
+}
+VIDEO_EXTENSIONS = {"mp4", "avi", "mov", "mkv", "flv", "wmv", "webm", "m4v", "3gp"}
+AUDIO_EXTENSIONS = {"mp3", "wav", "flac", "aac", "ogg", "wma", "m4a"}
+DOCUMENT_EXTENSIONS = {
+    "pdf",
+    "doc",
+    "docx",
+    "xls",
+    "xlsx",
+    "ppt",
+    "pptx",
+    "txt",
+    "md",
+    "csv",
+    "json",
+    "xml",
+    "html",
+    "htm",
+}
+TEXT_PREVIEW_EXTENSIONS = {"txt", "md", "csv", "json", "xml", "html", "htm", "log"}
+TEXT_PREVIEW_MAX_BYTES = 200_000

{licos_agent_runtime-0.2.2 → licos_agent_runtime-0.2.6}/src/licos_agent_runtime/graph_loader.py

@@ -176,7 +176,7 @@ def _load_from_module(module_name: str, candidates: tuple[str, ...], ctx: Contex
 def get_agent_instance(module_name: str = "agents.agent", ctx: Context | None = None) -> Any:
     return _load_from_module(
         module_name,
-        ("create_agent", "get_agent", "agent", "graph", "app", "builder"),
+        ("create_agent", "build_agent", "get_agent", "agent", "graph", "app", "builder"),
         ctx,
     )
 
@@ -304,6 +304,11 @@ def get_graph_node_func_with_inout(graph: Any, node_id: str) -> tuple[Any | None
         if current_id == node_id or getattr(item, "id", None) == node_id or getattr(item, "name", None) == node_id:
             node = item
             break
+        data = _node_data(item)
+        func = _resolve_callable(data)
+        if getattr(func, "__name__", None) == node_id:
+            node = item
+            break
 
     if node is None:
         return None, None, None