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

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/.gitignore

@@ -31,6 +31,7 @@ Thumbs.db
 
 # Build
 *.log
+*.pid
 .licos
 
 /tmp
@@ -43,4 +44,6 @@ Thumbs.db
 
 dist
 
-project-20260423_130440
+project-20260423_130440
+projects-20260425_workflow
+coze-skills

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

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

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

@@ -1,29 +1,29 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "licos-agent-runtime"
-version = "0.2.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.2.0",
-]
-
-[project.scripts]
-licos-agent-runtime = "licos_agent_runtime.__main__:main"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/licos_agent_runtime"]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "licos-agent-runtime"
+version = "0.2.2"
+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.2.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.2.0 → licos_agent_runtime-0.2.2}/src/licos_agent_runtime/graph_loader.py

@@ -93,19 +93,38 @@ def is_dev_env() -> bool:
 
 def is_agent_project(root: Path | None = None) -> bool:
     project_type = (os.environ.get("AGENT_PROJECT_TYPE") or os.environ.get("LICOS_PROJECT_TYPE") or "").strip()
-    if project_type.upper() == "AGENT":
+    normalized_type = project_type.upper()
+    if normalized_type == "AGENT":
         return True
+    if normalized_type == "WORKFLOW":
+        return False
 
     root = root or project_root()
     template = (_read_project_template(root) or "").upper()
     if template == "AGENT":
         return True
+    if template == "WORKFLOW":
+        return False
 
     return (root / "src" / "agents" / "agent.py").is_file() or (root / "agents" / "agent.py").is_file()
 
 
 def is_workflow_project(root: Path | None = None) -> bool:
-    return not is_agent_project(root)
+    project_type = (os.environ.get("AGENT_PROJECT_TYPE") or os.environ.get("LICOS_PROJECT_TYPE") or "").strip()
+    normalized_type = project_type.upper()
+    if normalized_type == "WORKFLOW":
+        return True
+    if normalized_type == "AGENT":
+        return False
+
+    root = root or project_root()
+    template = (_read_project_template(root) or "").upper()
+    if template == "WORKFLOW":
+        return True
+    if template == "AGENT":
+        return False
+
+    return (root / "src" / "graphs" / "graph.py").is_file() or (root / "graphs" / "graph.py").is_file()
 
 
 def _call_factory(factory: Any, ctx: Context | None) -> Any:

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/src/licos_agent_runtime/service.py

@@ -7,6 +7,7 @@ import json
 import logging
 import os
 import threading
+import time
 from typing import Any, AsyncIterable, Iterable
 
 from . import telemetry
@@ -34,6 +35,16 @@ from .parser import LangGraphParser
 from .parser import schema_to_json
 from .run_config import init_agent_config, init_run_config
 from .stream_runner import AgentStreamRunner, RunOpt, WorkflowStreamRunner
+from .workflow_protocol import (
+    DEFAULT_ERROR_CODE as WORKFLOW_DEFAULT_ERROR_CODE,
+    workflow_end_event,
+    workflow_error_event,
+    workflow_log_id,
+    workflow_node_end_event,
+    workflow_node_start_event,
+    workflow_ping_event,
+    workflow_start_event,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -57,6 +68,21 @@ async def _call_ainvoke(graph: Any, payload: dict[str, Any], run_config: dict[st
     return await graph.ainvoke(payload, **kwargs)
 
 
+def _call_astream_events(graph: Any, payload: dict[str, Any], run_config: dict[str, Any], ctx: Context) -> Any:
+    return graph.astream_events(
+        payload,
+        **_select_supported_kwargs(
+            graph.astream_events,
+            [
+                {"config": run_config, "context": ctx, "version": "v2"},
+                {"config": run_config, "version": "v2"},
+                {"config": run_config, "context": ctx},
+                {"config": run_config},
+            ],
+        ),
+    )
+
+
 def _select_supported_kwargs(method: Any, kwargs_list: list[dict[str, Any]]) -> dict[str, Any]:
     try:
         signature = inspect.signature(method)
@@ -108,7 +134,7 @@ class GraphService:
 
     @staticmethod
     def _sse_event(data: Any, event_id: Any = None) -> str:
-        id_line = f"id: {event_id}\n" if event_id else ""
+        id_line = f"id: {event_id}\n" if event_id is not None else ""
         return f"{id_line}event: message\ndata: {json.dumps(data, ensure_ascii=False, default=str)}\n\n"
 
     def _get_stream_runner(self) -> AgentStreamRunner | WorkflowStreamRunner:
@@ -132,8 +158,19 @@ class GraphService:
 
         try:
             graph = self._get_graph(ctx)
-            run_config = init_agent_config(graph, ctx) if is_agent_project() else init_run_config(graph, ctx)
+            agent_project = is_agent_project()
+            start_perf = time.perf_counter()
+            run_config = init_agent_config(graph, ctx) if agent_project else init_run_config(graph, ctx)
             result = await _call_ainvoke(graph, payload, run_config, ctx)
+            if not agent_project:
+                return {
+                    "run_id": run_id,
+                    "log_id": workflow_log_id(),
+                    "output": result if result is not None else {},
+                    "time_cost_ms": _elapsed_perf_ms(start_perf),
+                    "code": 0,
+                    "message": "success",
+                }
             if result is None:
                 result = {}
             if isinstance(result, dict):
@@ -181,7 +218,12 @@ class GraphService:
         run_opt = run_opt or RunOpt()
         run_id = ctx.run_id
         if run_opt.platform_stream_protocol:
-            async for item in self._stream_sse_platform(payload, ctx=ctx, run_opt=run_opt):
+            stream = (
+                self._stream_sse_agent_platform(payload, ctx=ctx, run_opt=run_opt)
+                if is_agent_project()
+                else self._stream_sse_workflow_platform(payload, ctx=ctx, run_opt=run_opt)
+            )
+            async for item in stream:
                 yield item
             return
 
@@ -201,7 +243,7 @@ class GraphService:
             self.running_tasks.pop(run_id, None)
             telemetry.flush()
 
-    async def _stream_sse_platform(
+    async def _stream_sse_agent_platform(
         self,
         payload: dict[str, Any],
         ctx: Context,
@@ -242,6 +284,157 @@ class GraphService:
             self.running_tasks.pop(run_id, None)
             telemetry.flush()
 
+    async def _stream_sse_workflow_platform(
+        self,
+        payload: dict[str, Any],
+        ctx: Context,
+        run_opt: RunOpt,
+    ) -> AsyncIterable[str]:
+        run_id = ctx.run_id
+        log_id = workflow_log_id()
+        start_perf = time.perf_counter()
+        event_index = 0
+
+        yield self._sse_event(workflow_start_event(run_id=run_id, log_id=log_id), event_index)
+        event_index += 1
+
+        queue: asyncio.Queue[dict[str, Any] | BaseException | None] = asyncio.Queue()
+
+        async def produce() -> None:
+            try:
+                async for event in self._workflow_platform_events(payload, ctx, log_id, start_perf):
+                    await queue.put(event)
+            except BaseException as exc:
+                await queue.put(exc)
+            finally:
+                await queue.put(None)
+
+        producer = asyncio.create_task(produce())
+        ping_interval = run_opt.workflow_ping_interval_seconds
+
+        try:
+            while True:
+                try:
+                    if ping_interval and ping_interval > 0:
+                        item = await asyncio.wait_for(queue.get(), timeout=ping_interval)
+                    else:
+                        item = await queue.get()
+                except asyncio.TimeoutError:
+                    yield self._sse_event(workflow_ping_event(run_id=run_id, log_id=log_id), event_index)
+                    event_index += 1
+                    continue
+
+                if item is None:
+                    break
+                if isinstance(item, BaseException):
+                    if isinstance(item, asyncio.CancelledError):
+                        raise item
+                    code = stream_error_code(item) or WORKFLOW_DEFAULT_ERROR_CODE
+                    message = str(item) or item.__class__.__name__
+                    yield self._sse_event(
+                        workflow_error_event(run_id=run_id, log_id=log_id, code=code, message=message),
+                        event_index,
+                    )
+                    event_index += 1
+                    break
+
+                yield self._sse_event(item, event_index)
+                event_index += 1
+        except asyncio.CancelledError:
+            producer.cancel()
+            yield self._sse_event(
+                workflow_error_event(run_id=run_id, log_id=log_id, code=1, message="cancelled"),
+                event_index,
+            )
+        finally:
+            with suppress(asyncio.CancelledError):
+                await producer
+            self.running_tasks.pop(run_id, None)
+            telemetry.flush()
+
+    async def _workflow_platform_events(
+        self,
+        payload: dict[str, Any],
+        ctx: Context,
+        log_id: str,
+        start_perf: float,
+    ) -> AsyncIterable[dict[str, Any]]:
+        graph = self._get_graph(ctx)
+        run_config = init_run_config(graph, ctx)
+        node_start_times: dict[str, float] = {}
+        final_output: Any = {}
+
+        if hasattr(graph, "astream_events"):
+            async for event in _call_astream_events(graph, payload, run_config, ctx):
+                if not isinstance(event, dict):
+                    continue
+                event_type = str(event.get("event") or "")
+                name = str(event.get("name") or "")
+                event_run_id = str(event.get("run_id") or name or ctx.run_id)
+                data = event.get("data") if isinstance(event.get("data"), dict) else {}
+
+                if event_type.endswith("_start") and not _is_workflow_root_event(event):
+                    node_start_times[event_run_id] = time.perf_counter()
+                    yield workflow_node_start_event(
+                        run_id=ctx.run_id,
+                        log_id=log_id,
+                        node_name=self._workflow_node_name(graph, name),
+                        input=data.get("input", {}),
+                    )
+                    continue
+
+                if event_type.endswith("_end"):
+                    output = data.get("output", {})
+                    if _is_workflow_root_event(event) or event_run_id not in node_start_times:
+                        if output:
+                            final_output = output
+                        continue
+                    node_started = node_start_times.pop(event_run_id, time.perf_counter())
+                    yield workflow_node_end_event(
+                        run_id=ctx.run_id,
+                        log_id=log_id,
+                        node_name=self._workflow_node_name(graph, name),
+                        output=output,
+                        time_cost_ms=_elapsed_perf_ms(node_started),
+                    )
+                    if output:
+                        final_output = output
+                    continue
+
+                if event_type.endswith("_error"):
+                    error = data.get("error") or data.get("exception") or "workflow node failed"
+                    yield workflow_error_event(
+                        run_id=ctx.run_id,
+                        log_id=log_id,
+                        code=WORKFLOW_DEFAULT_ERROR_CODE,
+                        message=str(error),
+                    )
+
+            yield workflow_end_event(
+                run_id=ctx.run_id,
+                log_id=log_id,
+                output=final_output,
+                time_cost_ms=_elapsed_perf_ms(start_perf),
+            )
+            return
+
+        result = await _call_ainvoke(graph, payload, run_config, ctx)
+        yield workflow_end_event(
+            run_id=ctx.run_id,
+            log_id=log_id,
+            output=result,
+            time_cost_ms=_elapsed_perf_ms(start_perf),
+        )
+
+    def _workflow_node_name(self, graph: Any, node_id: str) -> str:
+        parser = LangGraphParser(graph)
+        metadata = parser.get_node_metadata(node_id) or {}
+        for key in ("title", "name", "label"):
+            value = metadata.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+        return node_id or "workflow_node"
+
     def cancel_run(self, run_id: str, ctx: Context | None = None) -> dict[str, Any]:
         del ctx
         logger.info("Attempting to cancel run_id=%s", run_id)
@@ -299,15 +492,16 @@ class GraphService:
         if output_cls is None and hasattr(graph, "get_output_schema"):
             output_cls = graph.get_output_schema()
 
-        parser = LangGraphParser(graph)
-
-        return {
+        result = {
             "input_schema": schema_to_json(input_cls),
             "output_schema": schema_to_json(output_cls),
-            "nodes": parser.get_nodes_metadata(),
-            "code": 0,
-            "msg": "",
         }
+        if is_agent_project():
+            parser = LangGraphParser(graph)
+            result["nodes"] = parser.get_nodes_metadata()
+            result["code"] = 0
+            result["msg"] = ""
+        return result
 
     async def astream(
         self,
@@ -320,3 +514,26 @@ class GraphService:
         stream_runner = self._get_stream_runner()
         async for chunk in stream_runner.astream(payload, graph, run_config, ctx, run_opt):
             yield chunk
+
+
+def _elapsed_perf_ms(start: float) -> int:
+    return max(0, int((time.perf_counter() - start) * 1000))
+
+
+def _is_workflow_root_event(event: dict[str, Any]) -> bool:
+    name = str(event.get("name") or "").lower()
+    if name.startswith("__"):
+        return True
+    if name in {"langgraph", "stategraph", "compiledstategraph", "graph", "__root__"}:
+        return True
+    metadata = event.get("metadata")
+    if isinstance(metadata, dict):
+        if metadata.get("langgraph_node") in {"__start__", "__end__"}:
+            return True
+        if metadata.get("langgraph_node") is None and name in {
+            "langgraph",
+            "graph",
+            "stategraph",
+        }:
+            return True
+    return False

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/src/licos_agent_runtime/stream_protocol.py

@@ -223,7 +223,7 @@ def chunk_to_events(chunk: Any) -> list[dict[str, Any]]:
     events.extend(_tool_events_from_chunk(chunk))
 
     answer = extract_answer(chunk)
-    if answer:
+    if answer and not _is_tool_only_chunk(chunk):
         events.append(answer_event(answer))
     return events
 
@@ -243,6 +243,14 @@ def _tool_events_from_chunk(chunk: Any) -> list[dict[str, Any]]:
         if isinstance(tool_response, dict):
             events.append(_tool_response_from_mapping(tool_response))
 
+        tool_calls = chunk.get("tool_calls")
+        if isinstance(tool_calls, list):
+            events.extend(_tool_requests_from_calls(tool_calls))
+
+        tool_call_chunks = chunk.get("tool_call_chunks")
+        if isinstance(tool_call_chunks, list):
+            events.extend(_tool_requests_from_calls(tool_call_chunks))
+
         messages = chunk.get("messages")
         if isinstance(messages, list):
             for message in messages:
@@ -259,8 +267,10 @@ def _tool_events_from_chunk(chunk: Any) -> list[dict[str, Any]]:
 def _tool_events_from_message(message: Any) -> list[dict[str, Any]]:
     events: list[dict[str, Any]] = []
     tool_calls = None
+    tool_call_chunks = None
     if isinstance(message, dict):
         tool_calls = message.get("tool_calls")
+        tool_call_chunks = message.get("tool_call_chunks")
         if message.get("tool_call_id") and not tool_calls:
             events.append(
                 tool_response_event(
@@ -271,6 +281,7 @@ def _tool_events_from_message(message: Any) -> list[dict[str, Any]]:
             )
     else:
         tool_calls = getattr(message, "tool_calls", None)
+        tool_call_chunks = getattr(message, "tool_call_chunks", None)
         tool_call_id = getattr(message, "tool_call_id", None)
         if tool_call_id:
             events.append(
@@ -282,26 +293,64 @@ def _tool_events_from_message(message: Any) -> list[dict[str, Any]]:
             )
 
     if isinstance(tool_calls, list):
-        is_parallel = len(tool_calls) > 1
-        for index, call in enumerate(tool_calls):
-            if isinstance(call, dict):
-                events.append(_tool_request_from_mapping(call, index, is_parallel))
+        events.extend(_tool_requests_from_calls(tool_calls))
+    if isinstance(tool_call_chunks, list):
+        events.extend(_tool_requests_from_calls(tool_call_chunks))
+    return events
+
+
+def _tool_requests_from_calls(calls: list[Any]) -> list[dict[str, Any]]:
+    events: list[dict[str, Any]] = []
+    is_parallel = len(calls) > 1
+    for index, call in enumerate(calls):
+        mapping = _object_to_mapping(call)
+        if mapping:
+            events.append(_tool_request_from_mapping(mapping, index, is_parallel))
     return events
 
 
+def _object_to_mapping(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+
+    mapping: dict[str, Any] = {}
+    for name in (
+        "tool_call_id",
+        "id",
+        "tool_name",
+        "name",
+        "parameters",
+        "args",
+        "arguments",
+        "is_parallel",
+        "index",
+        "stream_parameters",
+        "code",
+        "message",
+        "result",
+        "content",
+    ):
+        if hasattr(value, name):
+            mapping[name] = getattr(value, name)
+    return mapping
+
+
 def _tool_request_from_mapping(value: dict[str, Any], index: int, is_parallel: bool) -> dict[str, Any]:
     parameters = value.get("parameters")
     if parameters is None:
         parameters = value.get("args")
     if parameters is None:
         parameters = value.get("arguments")
+    stream_parameters = value.get("stream_parameters")
+    if stream_parameters is None and isinstance(parameters, str):
+        stream_parameters = parameters
     return tool_request_event(
         tool_call_id=str(value.get("tool_call_id") or value.get("id") or ""),
         tool_name=str(value.get("tool_name") or value.get("name") or ""),
-        parameters=parameters or {},
+        parameters=_parameters_object(parameters),
         is_parallel=bool(value.get("is_parallel", is_parallel)),
         index=int(value.get("index", index) or 0),
-        stream_parameters=str(value.get("stream_parameters") or ""),
+        stream_parameters=str(stream_parameters or ""),
     )
 
 
@@ -316,6 +365,36 @@ def _tool_response_from_mapping(value: dict[str, Any]) -> dict[str, Any]:
     )
 
 
+def _parameters_object(value: Any) -> dict[str, Any]:
+    if value is None or value == "":
+        return {}
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+        except json.JSONDecodeError:
+            return {"value": value}
+        if isinstance(parsed, dict):
+            return parsed
+        return {"value": parsed}
+    return {"value": value}
+
+
+def _is_tool_only_chunk(chunk: Any) -> bool:
+    if isinstance(chunk, dict):
+        if "messages" in chunk:
+            return False
+        return any(key in chunk for key in ("tool_request", "tool_response", "tool_call_id"))
+
+    if getattr(chunk, "tool_call_id", None):
+        return True
+
+    content = getattr(chunk, "content", None)
+    has_tool_request = bool(getattr(chunk, "tool_calls", None) or getattr(chunk, "tool_call_chunks", None))
+    return has_tool_request and not content
+
+
 def extract_answer(value: Any) -> str:
     if value is None:
         return ""

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/src/licos_agent_runtime/stream_runner.py

@@ -13,6 +13,7 @@ class RunOpt:
     workflow_debug: bool = False
     stream_mode: str | None = None
     platform_stream_protocol: bool = False
+    workflow_ping_interval_seconds: float = 15.0
 
 
 def _call_with_fallback(method: Any, payload: dict[str, Any], kwargs_list: list[dict[str, Any]]) -> Any:

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/src/licos_agent_runtime/telemetry.py

@@ -1,22 +1,22 @@
-from __future__ import annotations
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-def flush() -> None:
-    """Flush platform telemetry when available.
-
-    This is intentionally a no-op until licos-platform-sdk exposes telemetry.
-    The function mirrors the runtime flush hook so request handlers can
-    keep the same lifecycle shape.
-    """
-    try:
-        from licos_platform_sdk import telemetry  # type: ignore
-
-        flush_func = getattr(telemetry, "flush", None)
-        if callable(flush_func):
-            flush_func()
-    except Exception as exc:
-        logger.debug("telemetry flush skipped: %s", exc)
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def flush() -> None:
+    """Flush platform telemetry when available.
+
+    This is intentionally a no-op until licos-platform-sdk exposes telemetry.
+    The function mirrors the runtime flush hook so request handlers can
+    keep the same lifecycle shape.
+    """
+    try:
+        from licos_platform_sdk import telemetry  # type: ignore
+
+        flush_func = getattr(telemetry, "flush", None)
+        if callable(flush_func):
+            flush_func()
+    except Exception as exc:
+        logger.debug("telemetry flush skipped: %s", exc)

licos_agent_runtime-0.2.2/src/licos_agent_runtime/workflow_protocol.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any
+
+
+DEFAULT_ERROR_CODE = 201001
+
+
+def workflow_timestamp_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def workflow_log_id(timestamp_ms: int | None = None) -> str:
+    timestamp_ms = timestamp_ms if timestamp_ms is not None else workflow_timestamp_ms()
+    prefix = time.strftime("%Y%m%d%H%M%S", time.localtime(timestamp_ms / 1000))
+    return f"{prefix}{uuid.uuid4().hex[:16].upper()}"
+
+
+def workflow_start_event(
+    *,
+    run_id: str,
+    log_id: str,
+    timestamp: int | None = None,
+) -> dict[str, Any]:
+    return {
+        "type": "workflow_start",
+        "timestamp": timestamp if timestamp is not None else workflow_timestamp_ms(),
+        "run_id": run_id,
+        "log_id": log_id,
+    }
+
+
+def workflow_end_event(
+    *,
+    run_id: str,
+    log_id: str,
+    output: Any,
+    time_cost_ms: int,
+    timestamp: int | None = None,
+) -> dict[str, Any]:
+    return {
+        "type": "workflow_end",
+        "timestamp": timestamp if timestamp is not None else workflow_timestamp_ms(),
+        "run_id": run_id,
+        "log_id": log_id,
+        "output": _object_output(output),
+        "time_cost_ms": time_cost_ms,
+    }
+
+
+def workflow_node_start_event(
+    *,
+    run_id: str,
+    log_id: str,
+    node_name: str,
+    input: Any,
+    timestamp: int | None = None,
+) -> dict[str, Any]:
+    return {
+        "type": "node_start",
+        "timestamp": timestamp if timestamp is not None else workflow_timestamp_ms(),
+        "run_id": run_id,
+        "log_id": log_id,
+        "node_name": node_name,
+        "input": _object_output(input),
+    }
+
+
+def workflow_node_end_event(
+    *,
+    run_id: str,
+    log_id: str,
+    node_name: str,
+    output: Any,
+    time_cost_ms: int,
+    timestamp: int | None = None,
+) -> dict[str, Any]:
+    return {
+        "type": "node_end",
+        "timestamp": timestamp if timestamp is not None else workflow_timestamp_ms(),
+        "run_id": run_id,
+        "log_id": log_id,
+        "node_name": node_name,
+        "output": _object_output(output),
+        "time_cost_ms": time_cost_ms,
+    }
+
+
+def workflow_error_event(
+    *,
+    run_id: str,
+    log_id: str,
+    code: int,
+    message: str,
+    timestamp: int | None = None,
+) -> dict[str, Any]:
+    del run_id, log_id
+    return {
+        "type": "error",
+        "code": code,
+        "message": message,
+        "timestamp": timestamp if timestamp is not None else workflow_timestamp_ms(),
+    }
+
+
+def workflow_ping_event(
+    *,
+    run_id: str,
+    log_id: str,
+    timestamp: int | None = None,
+) -> dict[str, Any]:
+    del run_id, log_id
+    return {
+        "type": "ping",
+        "timestamp": timestamp if timestamp is not None else workflow_timestamp_ms(),
+    }
+
+
+def _object_output(value: Any) -> Any:
+    if value is None:
+        return {}
+    model_dump = getattr(value, "model_dump", None)
+    if callable(model_dump):
+        dumped = model_dump()
+        return dumped if isinstance(dumped, dict) else {"value": dumped}
+    if isinstance(value, dict):
+        return value
+    return {"value": value}

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/tests/test_graph_loader.py

@@ -10,6 +10,7 @@ from licos_agent_runtime.graph_loader import (
     _iter_nodes,
     get_graph_node_func_with_inout,
     is_agent_project,
+    is_workflow_project,
     project_root,
 )
 
@@ -20,6 +21,17 @@ class GraphLoaderTests(unittest.TestCase):
             with patch.dict(os.environ, {"AGENT_PROJECT_TYPE": "AGENT"}, clear=True):
                 self.assertTrue(is_agent_project(Path(tmp)))
 
+    def test_workflow_project_type_env_wins(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            agent_file = root / "src" / "agents" / "agent.py"
+            agent_file.parent.mkdir(parents=True)
+            agent_file.write_text("agent = object()\n", encoding="utf-8")
+
+            with patch.dict(os.environ, {"AGENT_PROJECT_TYPE": "WORKFLOW"}, clear=True):
+                self.assertFalse(is_agent_project(root))
+                self.assertTrue(is_workflow_project(root))
+
     def test_project_root_derives_from_workspace_path(self):
         with tempfile.TemporaryDirectory() as tmp:
             with patch.dict(os.environ, {"LICOS_WORKSPACE_PATH": tmp}, clear=True):
@@ -36,6 +48,29 @@ class GraphLoaderTests(unittest.TestCase):
             with patch.dict(os.environ, {}, clear=True):
                 self.assertTrue(is_agent_project(root))
 
+    def test_licos_template_workflow_is_workflow_project(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / ".licos").write_text(
+                '[project]\ntemplate = "workflow"\n',
+                encoding="utf-8",
+            )
+
+            with patch.dict(os.environ, {}, clear=True):
+                self.assertFalse(is_agent_project(root))
+                self.assertTrue(is_workflow_project(root))
+
+    def test_graph_module_marks_workflow_project(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            graph_file = root / "src" / "graphs" / "graph.py"
+            graph_file.parent.mkdir(parents=True)
+            graph_file.write_text("graph = object()\n", encoding="utf-8")
+
+            with patch.dict(os.environ, {}, clear=True):
+                self.assertFalse(is_agent_project(root))
+                self.assertTrue(is_workflow_project(root))
+
     def test_licos_config_dir_template_agent_is_agent_project(self):
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)

{licos_agent_runtime-0.2.0 → licos_agent_runtime-0.2.2}/tests/test_stream_protocol.py

@@ -60,6 +60,55 @@ class StreamProtocolTests(unittest.TestCase):
         self.assertEqual(request["content"]["tool_request"]["parameters"], {"q": "x"})
         self.assertEqual(response["content"]["tool_response"]["result"], '{"ok": true}')
 
+    def test_chunk_to_events_extracts_tool_call_chunks(self):
+        class ToolCallChunk:
+            id = "call-1"
+            name = "search"
+            args = '{"q":"x"}'
+            index = 0
+
+        class AIMessageChunk:
+            content = ""
+            tool_call_chunks = [ToolCallChunk()]
+
+        events = chunk_to_events(AIMessageChunk())
+
+        self.assertEqual(len(events), 1)
+        request = events[0]["content"]["tool_request"]
+        self.assertEqual(request["tool_call_id"], "call-1")
+        self.assertEqual(request["tool_name"], "search")
+        self.assertEqual(request["parameters"], {"q": "x"})
+        self.assertEqual(request["stream_parameters"], '{"q":"x"}')
+
+    def test_chunk_to_events_extracts_object_tool_calls(self):
+        class ToolCall:
+            id = "call-1"
+            name = "search"
+            args = {"q": "x"}
+
+        class AIMessage:
+            content = ""
+            tool_calls = [ToolCall()]
+
+        events = chunk_to_events(AIMessage())
+
+        self.assertEqual(len(events), 1)
+        request = events[0]["content"]["tool_request"]
+        self.assertEqual(request["tool_call_id"], "call-1")
+        self.assertEqual(request["parameters"], {"q": "x"})
+
+    def test_chunk_to_events_does_not_emit_answer_for_tool_response_message(self):
+        class ToolMessage:
+            tool_call_id = "call-1"
+            name = "search"
+            content = "tool result"
+
+        events = chunk_to_events(ToolMessage())
+
+        self.assertEqual(len(events), 1)
+        self.assertEqual(events[0]["type"], "tool_response")
+        self.assertEqual(events[0]["content"]["tool_response"]["result"], "tool result")
+
     def test_chunk_to_events_extracts_answer_from_langgraph_node_update(self):
         events = chunk_to_events({"assistant": {"output": "hello"}})
 

licos_agent_runtime-0.2.2/tests/test_workflow_protocol.py

@@ -0,0 +1,137 @@
+import asyncio
+import json
+import unittest
+from unittest.mock import patch
+
+from licos_agent_runtime.context import new_context
+from licos_agent_runtime.service import GraphService
+from licos_agent_runtime.stream_runner import RunOpt
+from licos_agent_runtime.workflow_protocol import (
+    workflow_end_event,
+    workflow_error_event,
+    workflow_node_end_event,
+    workflow_node_start_event,
+    workflow_ping_event,
+    workflow_start_event,
+)
+
+
+def _event_data(raw_event):
+    data = None
+    event_id = None
+    for line in raw_event.splitlines():
+        if line.startswith("id:"):
+            event_id = int(line[3:].strip())
+        if line.startswith("data:"):
+            data = json.loads(line[5:].strip())
+    if data is None:
+        raise AssertionError(f"No data line in event: {raw_event}")
+    return event_id, data
+
+
+class WorkflowProtocolTests(unittest.TestCase):
+    def test_workflow_event_shapes(self):
+        self.assertEqual(workflow_start_event(run_id="r1", log_id="l1", timestamp=1)["type"], "workflow_start")
+        self.assertEqual(
+            workflow_node_start_event(
+                run_id="r1",
+                log_id="l1",
+                node_name="search",
+                input={"topic": "x"},
+                timestamp=2,
+            ),
+            {
+                "type": "node_start",
+                "timestamp": 2,
+                "run_id": "r1",
+                "log_id": "l1",
+                "node_name": "search",
+                "input": {"topic": "x"},
+            },
+        )
+        self.assertEqual(
+            workflow_node_end_event(
+                run_id="r1",
+                log_id="l1",
+                node_name="search",
+                output={"items": []},
+                time_cost_ms=3,
+                timestamp=4,
+            )["type"],
+            "node_end",
+        )
+        self.assertEqual(
+            workflow_end_event(
+                run_id="r1",
+                log_id="l1",
+                output={"ok": True},
+                time_cost_ms=5,
+                timestamp=6,
+            )["output"],
+            {"ok": True},
+        )
+        self.assertEqual(workflow_error_event(run_id="r1", log_id="l1", code=201001, message="bad")["type"], "error")
+        self.assertEqual(workflow_ping_event(run_id="r1", log_id="l1")["type"], "ping")
+
+    def test_stream_sse_outputs_workflow_protocol_events(self):
+        class Node:
+            metadata = {"title": "网络搜索"}
+
+        class RawGraph:
+            nodes = {"search": Node()}
+
+        class Graph:
+            def get_graph(self):
+                return RawGraph()
+
+            async def astream_events(self, payload, **kwargs):
+                del kwargs
+                yield {
+                    "event": "on_chain_start",
+                    "name": "search",
+                    "run_id": "node-run",
+                    "data": {"input": payload},
+                }
+                yield {
+                    "event": "on_chain_end",
+                    "name": "search",
+                    "run_id": "node-run",
+                    "data": {"output": {"result": "node-ok"}},
+                }
+                yield {
+                    "event": "on_chain_end",
+                    "name": "LangGraph",
+                    "run_id": "graph-run",
+                    "data": {"output": {"answer": "done"}},
+                }
+
+        class Service(GraphService):
+            def _get_graph(self, ctx=None):
+                del ctx
+                return Graph()
+
+        async def run():
+            service = Service()
+            ctx = new_context("stream_run")
+            events = []
+            async for item in service.stream_sse(
+                {"topic": "AI"},
+                ctx=ctx,
+                run_opt=RunOpt(platform_stream_protocol=True, workflow_ping_interval_seconds=0),
+            ):
+                events.append(_event_data(item))
+            return events
+
+        with patch("licos_agent_runtime.service.is_agent_project", return_value=False):
+            events = asyncio.run(run())
+
+        ids = [event_id for event_id, _data in events]
+        types = [data["type"] for _event_id, data in events]
+        self.assertEqual(ids, [0, 1, 2, 3])
+        self.assertEqual(types, ["workflow_start", "node_start", "node_end", "workflow_end"])
+        self.assertEqual(events[1][1]["node_name"], "网络搜索")
+        self.assertEqual(events[-1][1]["output"], {"answer": "done"})
+
+
+if __name__ == "__main__":
+    unittest.main()