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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-agent-runtime
-Version: 0.2.6
+Version: 0.2.8
 Summary: LICOS Python agent runtime for LangGraph/LangChain projects
 Requires-Python: >=3.10
 Requires-Dist: fastapi<1,>=0.121

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-agent-runtime"
-version = "0.2.6"
+version = "0.2.8"
 description = "LICOS Python agent runtime for LangGraph/LangChain projects"
 requires-python = ">=3.10"
 dependencies = [

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

@@ -5,7 +5,7 @@ import inspect
 import os
 import sys
 from pathlib import Path
-from typing import Any
+from typing import Any, get_type_hints
 
 from .context import Context
 
@@ -217,7 +217,7 @@ def _node_data(node: Any) -> Any:
     for attr in ("data", "func", "runnable", "node", "callable"):
         try:
             value = inspect.getattr_static(node, attr)
-            if isinstance(value, property):
+            if isinstance(value, property) or type(value).__name__ == "_tuplegetter":
                 value = getattr(node, attr, None)
         except AttributeError:
             value = getattr(node, attr, None)
@@ -229,14 +229,16 @@ def _node_data(node: Any) -> Any:
 def _resolve_callable(value: Any) -> Any | None:
     if value is None:
         return None
-    if callable(value) or hasattr(value, "invoke") or hasattr(value, "ainvoke"):
-        return value
     for attr in ("func", "afunc", "bound", "runnable", "node", "callable"):
         nested = getattr(value, attr, None)
+        if inspect.ismethod(nested) and getattr(nested, "__self__", None) is value:
+            nested = nested.__func__
         if nested is not None and nested is not value:
             resolved = _resolve_callable(nested)
             if resolved is not None:
                 return resolved
+    if callable(value) or hasattr(value, "invoke") or hasattr(value, "ainvoke"):
+        return value
     return None
 
 
@@ -257,18 +259,23 @@ def _schema_from_signature(value: Any, kind: str) -> Any | None:
         signature = inspect.signature(value)
     except (TypeError, ValueError):
         return None
+    try:
+        type_hints = get_type_hints(value)
+    except Exception:
+        type_hints = {}
 
     if kind == "input":
         for parameter in signature.parameters.values():
-            if parameter.name in {"self", "config", "context", "ctx"}:
+            if parameter.name in {"self", "config", "context", "ctx", "runtime"}:
                 continue
-            if parameter.annotation is not inspect.Signature.empty:
-                return parameter.annotation
+            annotation = type_hints.get(parameter.name, parameter.annotation)
+            if annotation is not inspect.Signature.empty and not isinstance(annotation, str):
+                return annotation
             return None
         return None
 
-    annotation = signature.return_annotation
-    if annotation is inspect.Signature.empty:
+    annotation = type_hints.get("return", signature.return_annotation)
+    if annotation is inspect.Signature.empty or isinstance(annotation, str):
         return None
     return annotation
 
@@ -315,6 +322,6 @@ def get_graph_node_func_with_inout(graph: Any, node_id: str) -> tuple[Any | None
 
     data = _node_data(node)
     func = _resolve_callable(data)
-    input_cls = _schema_from(node, "input") or _schema_from(data, "input") or _schema_from(func, "input")
-    output_cls = _schema_from(node, "output") or _schema_from(data, "output") or _schema_from(func, "output")
+    input_cls = _schema_from(node, "input") or _schema_from(func, "input") or _schema_from(data, "input")
+    output_cls = _schema_from(node, "output") or _schema_from(func, "output") or _schema_from(data, "output")
     return func, input_cls, output_cls

{licos_agent_runtime-0.2.6 → licos_agent_runtime-0.2.8}/src/licos_agent_runtime/service.py

@@ -109,6 +109,80 @@ def _select_supported_kwargs(method: Any, kwargs_list: list[dict[str, Any]]) ->
     return {}
 
 
+def _runtime_for_context(ctx: Context) -> Any:
+    try:
+        from langgraph.runtime import Runtime
+    except Exception:
+        return None
+    return Runtime(context=ctx)
+
+
+def _coerce_node_payload(payload: dict[str, Any], input_cls: Any | None) -> Any:
+    if input_cls is None or input_cls is dict or input_cls is Any:
+        return payload
+    if not isinstance(payload, dict):
+        return payload
+
+    validate = getattr(input_cls, "model_validate", None)
+    if callable(validate):
+        return validate(payload)
+
+    if inspect.isclass(input_cls):
+        try:
+            return input_cls(**payload)
+        except Exception:
+            return payload
+
+    return payload
+
+
+def _normalize_node_result(result: Any) -> Any:
+    dump = getattr(result, "model_dump", None)
+    if callable(dump):
+        return dump()
+    return result
+
+
+async def _call_node_callable(func: Any, payload: Any, run_config: dict[str, Any], ctx: Context) -> Any:
+    if hasattr(func, "ainvoke") and callable(func.ainvoke):
+        kwargs = _select_supported_kwargs(
+            func.ainvoke,
+            [
+                {"config": run_config, "context": ctx},
+                {"config": run_config},
+            ],
+        )
+        return _normalize_node_result(await func.ainvoke(payload, **kwargs))
+
+    if hasattr(func, "invoke") and callable(func.invoke):
+        kwargs = _select_supported_kwargs(
+            func.invoke,
+            [
+                {"config": run_config, "context": ctx},
+                {"config": run_config},
+            ],
+        )
+        return _normalize_node_result(func.invoke(payload, **kwargs))
+
+    if not callable(func):
+        raise TypeError("node is not callable")
+
+    runtime = _runtime_for_context(ctx)
+    kwargs = _select_supported_kwargs(
+        func,
+        [
+            {"config": run_config, "runtime": runtime, "context": ctx},
+            {"config": run_config, "runtime": runtime},
+            {"config": run_config, "context": ctx},
+            {"config": run_config},
+        ],
+    )
+    result = func(payload, **kwargs)
+    if inspect.isawaitable(result):
+        result = await result
+    return _normalize_node_result(result)
+
+
 class GraphService:
     def __init__(
         self,
@@ -501,22 +575,9 @@ class GraphService:
         node_func, input_cls, output_cls = get_graph_node_func_with_inout(raw_graph, node_id)
         if node_func is None:
             raise KeyError(f"node_id '{node_id}' not found")
-        if input_cls is None:
-            input_cls = dict
-
-        from langgraph.graph import END, StateGraph
-
-        parser = LangGraphParser(graph)
-        metadata = parser.get_node_metadata(node_id) or {}
-        state_graph_kwargs: dict[str, Any] = {"input_schema": input_cls}
-        if output_cls is not None:
-            state_graph_kwargs["output_schema"] = output_cls
-        single_node_graph = StateGraph(input_cls, **state_graph_kwargs)
-        single_node_graph.add_node("sn", node_func, metadata=metadata)
-        single_node_graph.set_entry_point("sn")
-        single_node_graph.add_edge("sn", END)
-        compiled = single_node_graph.compile()
-        return await _call_ainvoke(compiled, payload, init_run_config(compiled, ctx), ctx)
+        del output_cls
+        node_payload = _coerce_node_payload(payload, input_cls)
+        return await _call_node_callable(node_func, node_payload, init_run_config(graph, ctx), ctx)
 
     def graph_inout_schema(self) -> dict[str, Any]:
         graph = self._get_graph()

{licos_agent_runtime-0.2.6 → licos_agent_runtime-0.2.8}/src/licos_agent_runtime/workflow_canvas.py

@@ -158,6 +158,8 @@ def build_query_text(before_nodes: list[dict[str, Any]], diff: dict[str, Any]) -
         "2) 阅读 summary / instructions / stats，快速理解总体变更。\n"
         "3) 新增/删除节点：查看 adds/removes 中的 tree（带层级缩进）和 after/before（完整嵌套结构）了解节点详情，node 了解节点基本信息，container/prev_id/next_id 了解位置。\n"
         "4) 字段更新/约束/类型/顺序调整：查看 updates/reorders。\n\n"
+        "硬性要求：每个节点都必须保留 after.type / node.type 中的画布节点类型，并同步写入 graph.py 的 add_node metadata.type 与 AGENTS.md 节点清单；"
+        "例如 type=parallel 必须保持为 parallel，不能改写成 action。\n\n"
         "注意：prev_id/next_id 表示节点在流程中的前后顺序位置，不代表图的边连接关系。subtree 为辅助信息，以 tree 和 after/before 的层级结构为准。\n\n"
         "QueryDiff JSON:\n"
         f"{diff_json}"
@@ -246,7 +248,7 @@ def _dependencies(metadata: dict[str, Any]) -> dict[str, Any]:
     if isinstance(raw, dict):
         return {key: value for key, value in raw.items() if value not in (None, "", [], {})}
     result: dict[str, Any] = {}
-    llm_config = metadata.get("llm_config")
+    llm_config = metadata.get("llm_cfg") or metadata.get("llm_config")
     if isinstance(llm_config, str) and llm_config.strip():
         result["llm_config"] = [llm_config.strip()]
     elif isinstance(llm_config, list):

{licos_agent_runtime-0.2.6 → licos_agent_runtime-0.2.8}/tests/test_graph_loader.py

@@ -1,6 +1,7 @@
 import os
 import tempfile
 import unittest
+from collections import namedtuple
 from pathlib import Path
 from unittest.mock import patch
 
@@ -140,6 +141,65 @@ class GraphLoaderTests(unittest.TestCase):
 
         self.assertIs(func, real_node_name)
 
+    def test_get_graph_node_func_extracts_namedtuple_node_data(self):
+        GraphNode = namedtuple("GraphNode", ["id", "name", "data", "metadata"])
+
+        def node_func(payload):
+            return payload
+
+        class RawGraph:
+            nodes = {"node_a": GraphNode("node_a", "node_a", node_func, {})}
+
+        func, _input_cls, _output_cls = get_graph_node_func_with_inout(RawGraph(), "node_a")
+
+        self.assertIs(func, node_func)
+
+    def test_get_graph_node_func_prefers_wrapped_callable_func(self):
+        def node_func(payload):
+            return payload
+
+        class RunnableLike:
+            func = node_func
+
+            def __call__(self, payload):
+                return self.func(payload)
+
+        class Node:
+            data = RunnableLike()
+
+        class RawGraph:
+            nodes = {"node_a": Node()}
+
+        func, _input_cls, _output_cls = get_graph_node_func_with_inout(RawGraph(), "node_a")
+
+        self.assertIs(func, node_func)
+
+    def test_get_graph_node_func_resolves_future_annotations(self):
+        namespace = {}
+        exec(
+            "from __future__ import annotations\n"
+            "class Input: pass\n"
+            "class Output: pass\n"
+            "def node_func(state: Input) -> Output:\n"
+            "    return Output()\n",
+            namespace,
+        )
+        node_func = namespace["node_func"]
+        input_cls = namespace["Input"]
+        output_cls = namespace["Output"]
+
+        class Node:
+            data = node_func
+
+        class RawGraph:
+            nodes = {"node_a": Node()}
+
+        func, resolved_input, resolved_output = get_graph_node_func_with_inout(RawGraph(), "node_a")
+
+        self.assertIs(func, node_func)
+        self.assertIs(resolved_input, input_cls)
+        self.assertIs(resolved_output, output_cls)
+
     def test_call_factory_does_not_swallow_internal_type_error(self):
         def factory(_ctx):
             raise TypeError("internal")

{licos_agent_runtime-0.2.6 → licos_agent_runtime-0.2.8}/tests/test_workflow_protocol.py

@@ -94,6 +94,145 @@ class WorkflowProtocolTests(unittest.TestCase):
         self.assertIn("#L", nodes[1]["script"]["content"])
         self.assertEqual(nodes[2]["definition"]["inputs"]["properties"]["answer"]["type"], "string")
 
+    def test_workflow_canvas_maps_llm_cfg_to_llm_config_dependency(self):
+        def analyze_topic(state):
+            return {"answer": state.get("topic", "")}
+
+        class Node:
+            metadata = {
+                "title": "智能分析",
+                "type": "agent",
+                "llm_cfg": "config/analyze_topic_cfg.json",
+            }
+            data = analyze_topic
+
+        class RawGraph:
+            nodes = {"analyze_topic": Node()}
+
+        class Graph:
+            def get_graph(self):
+                return RawGraph()
+
+        class Service(GraphService):
+            def _get_graph(self, ctx=None):
+                del ctx
+                return Graph()
+
+        with patch("licos_agent_runtime.service.is_agent_project", return_value=False):
+            result = Service().agent_canvas()
+
+        nodes = json.loads(result["data"]["data"])["nodes"]
+        self.assertEqual(nodes[1]["type"], "agent")
+        self.assertEqual(
+            nodes[1]["definition"]["info"]["dependencies"]["llm_config"],
+            ["config/analyze_topic_cfg.json"],
+        )
+
+    def test_run_node_executes_node_callable_directly(self):
+        def generate_answer(state):
+            return {"answer": state.get("topic", "")}
+
+        class Node:
+            metadata = {"title": "生成结果", "type": "action"}
+            data = generate_answer
+
+        class RawGraph:
+            nodes = {"generate_answer": Node()}
+
+        class Graph:
+            def get_graph(self):
+                return RawGraph()
+
+        class Service(GraphService):
+            def _get_graph(self, ctx=None):
+                del ctx
+                return Graph()
+
+        result = asyncio.run(
+            Service().run_node("generate_answer", {"topic": "单节点测试"}, new_context("test_node_run"))
+        )
+
+        self.assertEqual(result, {"answer": "单节点测试"})
+
+    def test_run_node_passes_config_and_runtime_when_supported(self):
+        runtime_marker = object()
+
+        def generate_answer(state, config, runtime):
+            return {
+                "answer": state.get("topic", ""),
+                "has_config": "configurable" in config,
+                "has_runtime": runtime is runtime_marker,
+            }
+
+        class Node:
+            metadata = {"title": "生成结果", "type": "action"}
+            data = generate_answer
+
+        class RawGraph:
+            nodes = {"generate_answer": Node()}
+
+        class Graph:
+            def get_graph(self):
+                return RawGraph()
+
+        class Service(GraphService):
+            def _get_graph(self, ctx=None):
+                del ctx
+                return Graph()
+
+        with patch("licos_agent_runtime.service._runtime_for_context", return_value=runtime_marker):
+            result = asyncio.run(
+                Service().run_node("generate_answer", {"topic": "单节点测试"}, new_context("test_node_run"))
+            )
+
+        self.assertEqual(result["answer"], "单节点测试")
+        self.assertTrue(result["has_config"])
+        self.assertTrue(result["has_runtime"])
+
+    def test_run_node_coerces_payload_to_node_input_schema(self):
+        class Input:
+            def __init__(self, topic):
+                self.topic = topic
+
+            @classmethod
+            def model_validate(cls, payload):
+                return cls(payload["topic"])
+
+        class Output:
+            def __init__(self, answer):
+                self.answer = answer
+
+            def model_dump(self):
+                return {"answer": self.answer}
+
+        def generate_answer(state):
+            return Output(state.topic)
+
+        generate_answer.input_schema = Input
+        generate_answer.output_schema = Output
+
+        class Node:
+            metadata = {"title": "生成结果", "type": "action"}
+            data = generate_answer
+
+        class RawGraph:
+            nodes = {"generate_answer": Node()}
+
+        class Graph:
+            def get_graph(self):
+                return RawGraph()
+
+        class Service(GraphService):
+            def _get_graph(self, ctx=None):
+                del ctx
+                return Graph()
+
+        result = asyncio.run(
+            Service().run_node("generate_answer", {"topic": "单节点测试"}, new_context("test_node_run"))
+        )
+
+        self.assertEqual(result, {"answer": "单节点测试"})
+
     def test_canvas_submit_builds_query_diff_for_agent_execution(self):
         before = {
             "nodes": [
@@ -147,6 +286,7 @@ class WorkflowProtocolTests(unittest.TestCase):
         self.assertEqual(result["msg"], "")
         self.assertIn("当前流程结构", result["query"])
         self.assertIn("QueryDiff JSON", result["query"])
+        self.assertIn("必须保留 after.type", result["query"])
         self.assertEqual(result["display_text"], "2 个节点变更")
         self.assertEqual(result["draft_text"], "2 个节点已编辑")
         self.assertEqual(result["reference"]["type"], "workflow_canvas_edit")