service-forge 0.1.11__py3-none-any.whl

service_forge/workflow/nodes/llm/query_llm_node.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+import os
+
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+from service_forge.llm import chat_stream, Model
+
+class QueryLLMNode(Node):
+    DEFAULT_INPUT_PORTS = [
+        Port("prompt", str),
+        Port("system_prompt", str),
+        Port("temperature", float),
+        Port("TRIGGER", bool),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("response", str),
+    ]
+
+    AUTO_FILL_INPUT_PORTS = [('TRIGGER', True)]
+
+    def __init__(
+        self, 
+        name: str,
+    ) -> None:
+        super().__init__(
+            name,
+        )
+
+    async def _run(self, prompt: str, system_prompt: str, temperature: float) -> None:
+        if os.path.exists(system_prompt):
+            with open(system_prompt, "r") as f:
+                system_prompt = f.read()
+        if os.path.exists(prompt):
+            with open(prompt, "r") as f:
+                prompt = f.read()
+
+        print(f"prompt: {prompt} temperature: {temperature}")
+        response = chat_stream(prompt, system_prompt, Model.DEEPSEEK_V3_250324, temperature)
+        for chunk in response:
+            yield chunk

service_forge/workflow/nodes/nested/workflow_node.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+
+class WorkflowNode(Node):
+    from service_forge.workflow.workflow import Workflow
+    DEFAULT_INPUT_PORTS = [
+        Port("workflow", Workflow),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+    ]
+
+    def __init__(
+        self, 
+        name: str,
+    ) -> None:
+        super().__init__(
+            name,
+        )
+
+    async def _run(self, workflow: Workflow, **kwargs) -> None:
+        for input_port in self.input_ports:
+            if input_port.is_sub_workflow_input_port():
+                input_port.port.node.fill_input(input_port.port, input_port.value)
+        await workflow.run()

service_forge/workflow/nodes/output/kafka_output_node.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+from service_forge.api.kafka_api import KafkaApp
+from typing import Any
+
+class KafkaOutputNode(Node):
+    DEFAULT_INPUT_PORTS = [
+        Port("app", KafkaApp),
+        Port("topic", str),
+        Port("data_type", type),
+        Port("data", Any),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+    ]
+
+    def __init__(
+        self, 
+        name: str,
+    ) -> None:
+        super().__init__(
+            name,
+        )
+
+    async def _run(self, app: KafkaApp, topic: str, data_type: type, data: Any) -> None:
+        await app.send_message(topic, data_type, data)

service_forge/workflow/nodes/output/print_node.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+import asyncio
+from typing import AsyncIterator
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+
+class PrintNode(Node):
+    DEFAULT_INPUT_PORTS = [
+        Port("TRIGGER", bool),
+        Port("message", str),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+    ]
+
+    AUTO_FILL_INPUT_PORTS = [('TRIGGER', True)]
+
+    def __init__(
+        self, 
+        name: str,
+    ) -> None:
+        super().__init__(
+            name,
+        )
+
+    async def _run(self, message: str) -> AsyncIterator[str]:
+        for char in str(message):
+            await asyncio.sleep(0.1)
+            yield char

service_forge/workflow/nodes/test/if_console_input_node.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import AsyncIterator
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+
+class IfConsoleInputNode(Node):
+    DEFAULT_INPUT_PORTS = [
+        Port("TRIGGER", bool),
+        Port("condition", str),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("true", bool),
+        Port("false", bool),
+    ]
+
+    def __init__(
+        self, 
+        name: str,
+    ) -> None:
+        super().__init__(
+            name,
+        )
+
+    async def _run(self, condition: str) -> None:
+        while True:
+            user_input = await self._query_user(condition)
+            if user_input.lower() in ['y', 'yes']:
+                self.activate_output_edges(self.get_output_port_by_name('true'), True)
+                break
+            elif user_input.lower() in ['n', 'no']:
+                self.activate_output_edges(self.get_output_port_by_name('false'), False)
+                break

service_forge/workflow/nodes/test/time_consuming_node.py

@@ -0,0 +1,62 @@
+
+from __future__ import annotations
+import asyncio
+import uuid
+import json
+from typing import Any
+from ...node import Node
+from ...port import Port
+from ....api.routers.websocket.websocket_manager import websocket_manager
+
+# It's deprecated, just for testing
+class TimeConsumingNode(Node):
+    """模拟耗时节点，定期发送进度更新"""
+
+    DEFAULT_INPUT_PORTS = [
+        Port("input", Any)
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("output", Any)
+    ]
+
+    def __init__(self, name: str, duration: float = 2.0):
+        super().__init__(name)
+        self.duration = duration  # 总耗时（秒）
+        self.progress = 0.0
+        self.task_id = None
+
+    async def _run(self, input: Any = None, task_id: uuid.UUID = None) -> str:
+        """执行耗时任务，定期更新进度"""
+        # 保存任务ID（如果有）
+        if task_id is not None:
+            self.task_id = task_id
+
+        total_steps = 10
+        result = f"Completed {self.name} after {self.duration} seconds"
+
+        # 分步骤执行，每步更新进度
+        for i in range(total_steps + 1):
+            # 更新进度
+            self.progress = i / total_steps
+
+            # 发送进度更新
+            if self.task_id:
+                await websocket_manager.send_progress(
+                    self.task_id, 
+                    self.name, 
+                    self.progress
+                )
+
+            # 模拟耗时
+            if i < total_steps:  # 最后一步不需要等待
+                await asyncio.sleep(self.duration / total_steps)
+
+        # 获取输出端口并设置值
+        output_port = self.get_output_port_by_name('output')
+        output_port.prepare(result)
+
+        # 激活输出端口
+        self.activate_output_edges(output_port, result)
+
+        return result

service_forge/workflow/port.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from ..utils.workflow_clone import port_clone
+
+if TYPE_CHECKING:
+    from .node import Node
+
+class Port:
+    def __init__(
+        self,
+        name: str,
+        type: type,
+        node: Node = None,
+        port: Port = None,
+        value: Any = None,
+        default: Any = None,
+        is_extended: bool = False,
+        is_extended_generated: bool = False,
+    ) -> None:
+        self.name = name
+        self.type = type
+        self.node = node
+        self.port = port
+        self.value = value
+        # not used yet
+        self.default = default
+        self.is_prepared = False
+        self.is_extended = is_extended
+        self.is_extended_generated = is_extended_generated
+    
+    def is_sub_workflow_input_port(self) -> bool:
+        return self.port != None
+
+    def prepare(self, data: Any) -> None:
+        from ..utils.default_type_converter import type_converter
+        data = type_converter.convert(data, self.type, node=self.node)
+        self.value = data
+        self.is_prepared = True
+
+    def trigger(self) -> None:
+        if self.node is None:
+            return
+        if self in self.node.input_variables:
+            return
+        self.node.input_variables[self] = self.value
+        self.node.num_activated_input_edges += 1
+        if self.node.is_ready():
+            self.node.workflow.ready_nodes.append(self.node)
+
+    def activate(self, data: Any) -> None:
+        self.prepare(data)
+        self.trigger()
+
+    def get_extended_name(self) -> str:
+        if self.is_extended_generated:
+            return '_'.join(self.name.split('_')[:-1])
+        raise ValueError(f"Port {self.name} is not extended generated.")
+    
+    def get_extended_index(self) -> int:
+        if self.is_extended_generated:
+            return int(self.name.split('_')[-1])
+        raise ValueError(f"Port {self.name} is not extended generated.")
+
+    def _clone(self, node_map: dict[Node, Node]) -> Port:
+        return port_clone(self, node_map)
+
+# node port
+def create_port(name: str, type: type, node: Node = None, value: Any = None, port: Port = None) -> Port:
+    return Port(name, type, node, port, value)
+
+# workflow input port
+def create_workflow_input_port(name: str, port: Port, value: Any = None) -> Port:
+    if value is None:
+        value = port.value
+    return Port(name, port.type, port.node, port, value)
+
+# sub workflow input port
+# node is the node that the sub workflow is running on
+def create_sub_workflow_input_port(name: str, node: Node, port: Port, value: Any = None) -> Port:
+    if value is None:
+        value = port.value
+    return Port(name, port.type, node, port, value)
+
+PORT_DELIMITER = '|'
+
+def parse_port_name(port_name: str) -> tuple[str, str]:
+    if PORT_DELIMITER not in port_name or len(port_name.split(PORT_DELIMITER)) != 2:
+        raise ValueError(f"Invalid port name: {port_name}")
+    return port_name.split(PORT_DELIMITER)

service_forge/workflow/trigger.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+import asyncio
+from typing import AsyncIterator
+from abc import ABC, abstractmethod
+import uuid
+from .node import Node
+from .workflow_event import WorkflowResult
+
+class Trigger(Node, ABC):
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.trigger_queue = asyncio.Queue()
+        # for workflow result
+        self.result_queues: dict[uuid.UUID, asyncio.Queue[WorkflowResult]] = {}
+        # for node stream output
+        self.stream_queues: dict[uuid.UUID, asyncio.Queue[WorkflowResult]] = {}
+
+    @abstractmethod
+    async def _run(self) -> AsyncIterator[bool]:
+        ...
+
+    def trigger(self, task_id: uuid.UUID) -> bool:
+        self.prepare_output_edges(self.get_output_port_by_name('trigger'), True)
+        return task_id

service_forge/workflow/triggers/__init__.py

@@ -0,0 +1,6 @@
+from .once_trigger import OnceTrigger
+from .period_trigger import PeriodTrigger
+from .fast_api_trigger import FastAPITrigger
+from .kafka_api_trigger import KafkaAPITrigger
+from .websocket_api_trigger import WebSocketAPITrigger
+from .a2a_api_trigger import A2AAPITrigger

service_forge/workflow/triggers/a2a_api_trigger.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+from loguru import logger
+from service_forge.workflow.trigger import Trigger
+from typing import AsyncIterator, Any
+from service_forge.workflow.port import Port
+from google.protobuf.message import Message
+from google.protobuf.json_format import MessageToJson
+from fastapi import FastAPI
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentSkill,
+)
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.utils import new_agent_text_message
+from a2a.utils.constants import DEFAULT_RPC_URL, EXTENDED_AGENT_CARD_PATH, AGENT_CARD_WELL_KNOWN_PATH
+
+import json
+import uuid
+import asyncio
+from service_forge.workflow.workflow_event import WorkflowResult
+
+class A2AAgentExecutor(AgentExecutor):
+    def __init__(self, trigger: A2AAPITrigger):
+        self.trigger = trigger
+
+    @staticmethod
+    def serialize_result(result: Any) -> str:
+        if isinstance(result, Message):
+            return MessageToJson(
+                result,
+                preserving_proto_field_name=True
+            )
+        return json.dumps(result)
+
+    async def send_event(self, event_queue: EventQueue, item: WorkflowResult) -> None:
+        if item.is_error:
+            result = {
+                'event': 'error',
+                'detail': str(item.result)
+            }
+            await event_queue.enqueue_event(new_agent_text_message(json.dumps(result)))
+
+        if item.is_end:
+            result = {
+                'event': 'end',
+                'detail': self.serialize_result(item.result)
+            }
+            await event_queue.enqueue_event(new_agent_text_message(json.dumps(result)))
+
+        result = {
+            'event': 'data',
+            'data': self.serialize_result(item.result)
+        }
+        await event_queue.enqueue_event(new_agent_text_message(json.dumps(result)))
+
+    async def execute(
+        self,
+        context: RequestContext,
+        event_queue: EventQueue,
+    ) -> None:
+        task_id = uuid.uuid4()
+        self.trigger.result_queues[task_id] = asyncio.Queue()
+
+        self.trigger.trigger_queue.put_nowait({
+            'id': task_id,
+            'context': context,
+        })
+
+        # TODO: support stream output
+        if False:
+            self.trigger.stream_queues[task_id] = asyncio.Queue()
+            while True:
+                item = await self.trigger.stream_queues[task_id].get()
+                await self.send_event(event_queue, item)
+
+                if item.is_error or item.is_end:
+                    break
+
+            if task_id in self.trigger.stream_queues:
+                del self.trigger.stream_queues[task_id]
+        else:
+            result = await self.trigger.result_queues[task_id].get()
+            await self.send_event(event_queue, result)
+
+        if task_id in self.trigger.result_queues:
+            del self.trigger.result_queues[task_id]
+
+    async def cancel(
+        self, context: RequestContext, event_queue: EventQueue
+    ) -> None:
+        raise Exception('cancel not supported')
+
+
+class A2AAPITrigger(Trigger):
+    DEFAULT_INPUT_PORTS = [
+        Port("app", FastAPI),
+        Port("path", str),
+        Port("skill_id", str, is_extended=True),
+        Port("skill_name", str, is_extended=True),
+        Port("skill_description", str, is_extended=True),
+        Port("skill_tags", list[str], is_extended=True),
+        Port("skill_examples", list[str], is_extended=True),
+        Port("agent_name", str),
+        Port("agent_url", str),
+        Port("agent_description", str),
+        Port("agent_version", str),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("trigger", bool),
+        Port("context", RequestContext),
+    ]
+
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.events = {}
+        self.is_setup_handler = False
+        self.agent_card: AgentCard | None = None
+
+    @staticmethod
+    def serialize_result(result: Any):
+        if isinstance(result, Message):
+            return MessageToJson(
+                result,
+                preserving_proto_field_name=True
+            )
+        return result
+
+    def _setup_handler(
+        self,
+        app: FastAPI,
+        path: str,
+        skill_id: list[tuple[int, str]],
+        skill_name: list[tuple[int, str]],
+        skill_description: list[tuple[int, str]],
+        skill_tags: list[tuple[int, list[str]]],
+        skill_examples: list[tuple[int, list[str]]],
+        agent_name: str,
+        agent_url: str,
+        agent_description: str,
+        agent_version: str,
+    ) -> None:
+    
+        skills_config = []
+        for i in range(len(skill_id)):
+            skills_config.append({
+                'id': '',
+                'name': '',
+                'description': '',
+                'tags': [],
+                'examples': [],
+            })
+
+        for i in range(len(skill_id)):
+            skills_config[skill_id[i][0]]['id'] = skill_id[i][1]
+            skills_config[skill_name[i][0]]['name'] = skill_name[i][1]
+            skills_config[skill_description[i][0]]['description'] = skill_description[i][1]
+            skills_config[skill_tags[i][0]]['tags'] = skill_tags[i][1]
+            skills_config[skill_examples[i][0]]['examples'] = skill_examples[i][1]
+    
+        skills = []
+        for config in skills_config:
+            skills.append(AgentSkill(
+                id=config['id'],
+                name=config['name'],
+                description=config['description'],
+                tags=config['tags'],
+                examples=config['examples'],
+            ))
+
+        agent_card = AgentCard(
+            name=agent_name,
+            description=agent_description,
+            url=agent_url,
+            version=agent_version,
+            default_input_modes=['text'],
+            default_output_modes=['text'],
+            capabilities=AgentCapabilities(streaming=True),
+            skills=skills,
+            supports_authenticated_extended_card=False,
+        )
+        
+        self.agent_card = agent_card
+
+        request_handler = DefaultRequestHandler(
+            agent_executor=A2AAgentExecutor(self),
+            task_store=InMemoryTaskStore(),
+        )
+
+        try:
+            server = A2AStarletteApplication(
+                agent_card=agent_card,
+                http_handler=request_handler,
+            )
+            
+            server.add_routes_to_app(
+                app,
+                agent_card_url="/a2a" + path + AGENT_CARD_WELL_KNOWN_PATH,
+                rpc_url="/a2a" + path + DEFAULT_RPC_URL,
+                extended_agent_card_url="/a2a" + path + EXTENDED_AGENT_CARD_PATH,
+            )
+
+        except Exception as e:
+            logger.error(f"Error adding A2A routes: {e}")
+            raise
+
+    async def _run(
+        self,
+        app: FastAPI,
+        path: str,
+        skill_id: list[tuple[int, str]],
+        skill_name: list[tuple[int, str]],
+        skill_description: list[tuple[int, str]],
+        skill_tags: list[tuple[int, list[str]]],
+        skill_examples: list[tuple[int, list[str]]],
+        agent_name: str,
+        agent_url: str,
+        agent_description: str,
+        agent_version: str,
+    ) -> AsyncIterator[bool]:
+        if len(skill_id) != len(skill_name) or len(skill_id) != len(skill_description) or len(skill_id) != len(skill_tags) or len(skill_id) != len(skill_examples):
+            raise ValueError("skill_id, skill_name, skill_description, skill_tags, skill_examples must have the same length")
+
+        if not self.is_setup_handler:
+            self._setup_handler(
+                app,
+                path,
+                skill_id,
+                skill_name,
+                skill_description,
+                skill_tags,
+                skill_examples,
+                agent_name,
+                agent_url,
+                agent_description,
+                agent_version,
+            )
+            self.is_setup_handler = True
+
+        logger.info(f"A2A Trigger {self.name} is running")
+
+        while True:
+            try:
+                trigger = await self.trigger_queue.get()
+                self.prepare_output_edges('context', trigger['context'])
+                yield self.trigger(trigger['id'])
+            except Exception as e:
+                logger.error(f"Error in A2AAPITrigger._run: {e}")
+                continue
+