service-forge 0.1.18__py3-none-any.whl → 0.1.28__py3-none-any.whl

service_forge/api/http_api.py

@@ -3,7 +3,7 @@ import uvicorn
 from fastapi import APIRouter
 from loguru import logger
 from urllib.parse import urlparse
-from fastapi import HTTPException, Request
+from fastapi import HTTPException, Request, WebSocket, WebSocketException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.utils import get_openapi
 from service_forge.api.routers.websocket.websocket_router import websocket_router
@@ -36,6 +36,88 @@ def is_trusted_origin(origin_host: str, host: str, trusted_root: str = "ring.shi
     )
 
 
+def validate_auth_from_headers(
+    headers: dict,
+    origin: str | None,
+    scheme: str,
+    host: str,
+    trusted_domain: str = "ring.shiweinan.com",
+) -> tuple[str | None, str | None]:
+    """
+    Validate authentication from headers and return user_id and token.
+    
+    Args:
+        headers: Dictionary of headers (can be from Request or WebSocket)
+        origin: Origin header value
+        scheme: URL scheme (http/https/ws/wss)
+        host: Host header value
+        trusted_domain: Trusted domain for origin validation
+        
+    Returns:
+        tuple: (user_id, auth_token) - user_id can be None if not authenticated and not same origin
+    """
+    is_same_origin = False
+    
+    logger.debug(f"origin {origin}, host:{host}")
+    
+    if origin and host:
+        try:
+            parsed_origin = urlparse(origin)
+            parsed_host = urlparse(f"{scheme}://{host}")
+            is_same_origin = (
+                parsed_origin.hostname == parsed_host.hostname
+                and parsed_origin.port == parsed_host.port
+                and is_trusted_origin(parsed_origin.hostname, parsed_host.hostname, trusted_domain)
+            )
+        except Exception:
+            pass
+    
+    user_id = headers.get("X-User-ID")
+    token = headers.get("X-User-Token")
+    
+    if not is_same_origin:
+        # For cross-origin requests, user_id is required
+        if not user_id:
+            return None, None
+        return user_id, token
+    else:
+        # For same-origin requests, user_id defaults to "0" if not provided
+        return user_id if user_id else "0", token
+
+
+async def authenticate_websocket(
+    websocket: WebSocket,
+    trusted_domain: str = "ring.shiweinan.com",
+) -> None:
+    """
+    Authenticate WebSocket connection and set user_id and auth_token in websocket.state.
+    
+    Args:
+        websocket: WebSocket instance
+        trusted_domain: Trusted domain for origin validation
+        
+    Raises:
+        WebSocketException: If authentication fails
+    """
+    origin = websocket.headers.get("origin") or websocket.headers.get("referer")
+    scheme = websocket.url.scheme
+    host = websocket.headers.get("host", "")
+    
+    user_id, token = validate_auth_from_headers(
+        websocket.headers,
+        origin,
+        scheme,
+        host,
+        trusted_domain,
+    )
+    
+    if user_id is None:
+        raise WebSocketException(code=1008, reason="Unauthorized")
+    
+    websocket.state.user_id = user_id
+    websocket.state.auth_token = token
+
+
 def create_app(
     app: FastAPI | None = None,
     routers: list[APIRouter] | None = None,
@@ -77,6 +159,10 @@ def create_app(
         for router in routers:
             app.include_router(router)
     
+    # Store auth configuration in app.state for WebSocket endpoints to access
+    app.state.enable_auth_middleware = enable_auth_middleware
+    app.state.trusted_domain = trusted_domain
+
     # Always include WebSocket router
     app.include_router(websocket_router)
 
@@ -100,31 +186,20 @@ def create_app(
                 origin = request.headers.get("origin") or request.headers.get("referer")
                 scheme = request.url.scheme
                 host = request.headers.get("host", "")
-                is_same_origin = False
                 
-                logger.debug(f"origin {origin}, host:{host}")
+                user_id, token = validate_auth_from_headers(
+                    request.headers,
+                    origin,
+                    scheme,
+                    host,
+                    trusted_domain,
+                )
+                
+                if user_id is None:
+                    raise HTTPException(status_code=401, detail="Unauthorized")
                 
-                if origin and host:
-                    try:
-                        parsed_origin = urlparse(origin)
-                        parsed_host = urlparse(f"{scheme}://{host}")
-                        is_same_origin = (
-                            parsed_origin.hostname == parsed_host.hostname
-                            and parsed_origin.port == parsed_host.port
-                            and is_trusted_origin(parsed_origin.hostname, parsed_host.hostname, trusted_domain)
-                        )
-                    except Exception:
-                        pass  # If parsing fails, continue with default behavior
-                if not is_same_origin:
-                    headers = request.headers
-                    user_id = headers.get("X-User-ID")
-                    if not user_id:
-                        raise HTTPException(status_code=401, detail="Unauthorized")
-                    
-                    request.state.user_id = user_id
-                else:
-                    # Same-origin requests can skip auth, but still set default user_id
-                    request.state.user_id = "0"  # Can be None or default value as needed
+                request.state.user_id = user_id
+                request.state.auth_token = token
 
             return await call_next(request)
     
@@ -147,6 +222,7 @@ async def start_fastapi_server(host: str, port: int):
 
 try:
     metadata = load_metadata("sf-meta.yaml")
-    fastapi_app = create_app(enable_auth_middleware=False, root_path=f"/api/v1/{get_service_url_name(metadata.name, metadata.version)}")
+    fastapi_app = create_app(enable_auth_middleware=metadata.enable_auth_middleware, root_path=f"/api/v1/{get_service_url_name(metadata.name, metadata.version)}")
 except Exception as e:
-    fastapi_app = create_app(enable_auth_middleware=False, root_path=None)
+    logger.warning(f"Failed to load metadata, using default configuration: {e}")
+    fastapi_app = create_app(enable_auth_middleware=True, root_path=None)

service_forge/api/routers/websocket/websocket_router.py

@@ -9,6 +9,19 @@ websocket_router = APIRouter()
 
 @websocket_router.websocket("/sdk/ws")
 async def sdk_websocket_endpoint(websocket: WebSocket):
+    # Authenticate WebSocket connection before accepting
+    # Get trusted_domain from app.state if available
+    # trusted_domain = getattr(websocket.app.state, "trusted_domain", "ring.shiweinan.com")
+    # enable_auth = getattr(websocket.app.state, "enable_auth_middleware", True)
+    
+    # if enable_auth:
+    #     from service_forge.api.http_api import authenticate_websocket
+    #     await authenticate_websocket(websocket, trusted_domain)
+    # else:
+    #     # If auth is disabled, set default values
+    #     websocket.state.user_id = websocket.headers.get("X-User-ID", "0")
+    #     websocket.state.auth_token = websocket.headers.get("X-User-Token")
+    
     await websocket.accept()
     try:
         while True:

service_forge/db/database.py

@@ -7,6 +7,7 @@ from typing import AsyncGenerator
 from loguru import logger
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
 from service_forge.service_config import ServiceConfig
+from pymongo import AsyncMongoClient
 
 class PostgresDatabase:
     def __init__(
@@ -114,6 +115,7 @@ class MongoDatabase:
         self.mongo_password = mongo_password
         self.mongo_db = mongo_db or ""
         self.client = pymongo.MongoClient(self.database_url)
+        self.async_client = AsyncMongoClient(self.database_url)
         self.test_connection()
 
     @property
@@ -129,6 +131,21 @@ class MongoDatabase:
             logger.error(f"MongoDB connection test failed for database '{self.name}': {e}")
             return False
 
+    async def test_async_connection(self) -> bool:
+        try:
+            await self.async_client.admin.command('ping')
+            logger.info(f"Async MongoDB connection test successful for database '{self.name}'")
+            return True
+        except Exception as e:
+            logger.error(f"Async MongoDB connection test failed for database '{self.name}': {e}")
+            return False
+
+    def get_sync_collection(self, collection_name: str):
+        return self.client[self.mongo_db][collection_name]
+
+    def get_async_collection(self, collection_name: str):
+        return self.async_client[self.mongo_db][collection_name]
+
 class RedisDatabase:
     def __init__(
         self,

service_forge/service.py

@@ -4,6 +4,7 @@ import os
 import asyncio
 import threading
 import uuid
+from importlib.metadata import version
 from loguru import logger
 from typing import Callable, AsyncIterator, Awaitable, Any, TYPE_CHECKING
 from service_forge.workflow.node import node_register
@@ -260,6 +261,12 @@ class Service:
     
     @staticmethod
     def from_config(metadata: SfMetadata, service_env: dict[str, Any] = None, config: ServiceConfig = None) -> Service:
+        try:
+            service_forge_version = version("service-forge")
+            logger.info(f"service-forge version: {service_forge_version}")
+        except Exception as e:
+            logger.warning(f"Failed to get service-forge version: {e}")
+        
         if config is not None:
             config_path = None
         else:

service_forge/sft/cli.py

@@ -9,6 +9,8 @@ from service_forge.sft.cmd.upload_service import upload_service
 from service_forge.sft.cmd.deploy_service import deploy_service
 from service_forge.sft.cmd.config_command import list_config, get_config, set_config
 from service_forge.sft.cmd.service_command import list_services, delete_service, show_service_logs
+from service_forge.sft.cmd.remote_list_tars import remote_list_tars
+from service_forge.sft.cmd.remote_deploy import remote_deploy_tar, remote_list_and_deploy
 
 app = typer.Typer(
     name="sft",
@@ -33,6 +35,43 @@ def list_tars_command() -> None:
 def deploy_service_command(name: str, version: str) -> None:
     deploy_service(name, version)
 
+@app.command(name="remote-list")
+def remote_list_tars_command(
+    url: str = typer.Option(
+        None,
+        "--url",
+        "-u",
+        help="Service Center URL (default: http://localhost:5000 or from service_center_address config)"
+    )
+) -> None:
+    """List tar packages and their status on remote server"""
+    remote_list_tars(url)
+
+@app.command(name="remote-deploy")
+def remote_deploy_command(
+    filename: str = typer.Argument(help="Filename of the tar package to deploy"),
+    url: str = typer.Option(
+        None,
+        "--url",
+        "-u",
+        help="Service Center URL (default: http://localhost:5000 or from service_center_address config)"
+    )
+) -> None:
+    """Remote deploy specified tar package"""
+    remote_deploy_tar(filename, url)
+
+@app.command(name="remote-deploy-interactive")
+def remote_deploy_interactive_command(
+    url: str = typer.Option(
+        None,
+        "--url",
+        "-u",
+        help="Service Center URL (default: http://localhost:5000 or from service_center_address config)"
+    )
+) -> None:
+    """Interactive remote deployment of tar packages (list available packages first, then select for deployment)"""
+    remote_list_and_deploy(url)
+
 config_app = typer.Typer(
     name="config",
     help="Configuration management commands",

service_forge/sft/cmd/remote_deploy.py

@@ -0,0 +1,160 @@
+import os
+import json
+import requests
+from pathlib import Path
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+from service_forge.sft.config.sft_config import sft_config
+
+def remote_deploy_tar(filename: str, service_center_url: str = None) -> None:
+    """
+    Remote deploy specified tar package from service-center
+    """
+    # If URL is not provided, try to get it from configuration
+    if not service_center_url:
+        service_center_url = getattr(sft_config, 'service_center_address', 'http://localhost:5000')
+    
+    # Ensure URL ends with /
+    if not service_center_url.endswith('/'):
+        service_center_url += '/'
+    
+    api_url = f"{service_center_url}api/v1/services/deploy-from-tar"
+    
+    log_info(f"Sending deployment request to {api_url}...")
+    log_info(f"Tar package to deploy: {filename}")
+    
+    try:
+        # Prepare request data
+        data = {
+            "filename": filename
+        }
+        
+        # Send POST request
+        response = requests.post(
+            api_url,
+            json=data,
+            headers={'Content-Type': 'application/json'},
+            timeout=300  # 5 minute timeout
+        )
+        
+        if response.status_code != 200:
+            log_error(f"Deployment request failed, status code: {response.status_code}")
+            try:
+                error_data = response.json()
+                log_error(f"Error message: {error_data.get('message', 'Unknown error')}")
+                if 'data' in error_data and error_data['data']:
+                    log_error(f"Details: {json.dumps(error_data['data'], indent=2, ensure_ascii=False)}")
+            except:
+                log_error(f"Response content: {response.text}")
+            return
+        
+        # Parse response data
+        result = response.json()
+        
+        if result.get('code') != 200:
+            log_error(f"Deployment failed: {result.get('message', 'Unknown error')}")
+            if 'data' in result and result['data']:
+                log_error(f"Details: {json.dumps(result['data'], indent=2, ensure_ascii=False)}")
+            return
+        
+        # Deployment successful
+        data = result.get('data', {})
+        service_name = data.get('service_name', 'Unknown')
+        version = data.get('version', 'Unknown')
+        deploy_output = data.get('deploy_output', '')
+        
+        log_success(f"Successfully deployed service: {service_name} version: {version}")
+        
+        if deploy_output:
+            log_info("Deployment output:")
+            print(deploy_output)
+        
+    except requests.exceptions.Timeout:
+        log_error("Deployment request timed out (exceeded 5 minutes), please check service status or try again later")
+    except requests.exceptions.RequestException as e:
+        log_error(f"Request failed: {str(e)}")
+        log_info(f"Please check if service-center service is running normally and if the URL is correct: {service_center_url}")
+    except Exception as e:
+        log_error(f"Exception occurred while deploying tar package: {str(e)}")
+
+def remote_list_and_deploy(service_center_url: str = None) -> None:
+    """
+    List remote tar packages first, then let user select which package to deploy
+    """
+    # If URL is not provided, try to get it from configuration
+    if not service_center_url:
+        service_center_url = getattr(sft_config, 'service_center_address', 'http://localhost:5000')
+    
+    # Ensure URL ends with /
+    if not service_center_url.endswith('/'):
+        service_center_url += '/'
+    
+    api_url = f"{service_center_url}api/v1/services/tar-list"
+    
+    log_info(f"Getting tar package list from {api_url}...")
+    
+    try:
+        # 发送GET请求获取tar包列表
+        response = requests.get(api_url, timeout=30)
+        
+        if response.status_code != 200:
+            log_error(f"Failed to get tar package list, status code: {response.status_code}")
+            return
+        
+        # Parse response data
+        result = response.json()
+        
+        if result.get('code') != 200:
+            log_error(f"Failed to get tar package list: {result.get('message', 'Unknown error')}")
+            return
+        
+        tar_files = result.get('data', [])
+        
+        if not tar_files:
+            log_info("No tar packages found")
+            return
+        
+        # Display tar package list
+        log_info("Available tar package list:")
+        for i, tar_file in enumerate(tar_files, 1):
+            filename = tar_file.get('filename', '-')
+            service_name = tar_file.get('service_name', '-')
+            version = tar_file.get('version', '-')
+            deployed_status = "Deployed" if tar_file.get('deployed_status', False) else "Not Deployed"
+            
+            print(f"{i}. {filename} (service: {service_name}, version: {version}, status: {deployed_status})")
+        
+        # Let user choose
+        try:
+            choice = input("\nEnter the number of the tar package to deploy (enter 'q' to exit): ").strip()
+            
+            if choice.lower() == 'q':
+                log_info("Deployment cancelled")
+                return
+            
+            index = int(choice) - 1
+            if 0 <= index < len(tar_files):
+                selected_tar = tar_files[index]
+                filename = selected_tar.get('filename')
+                
+                if selected_tar.get('deployed_status', False):
+                    log_warning(f"Tar package {filename} is already deployed, continue deployment?")
+                    confirm = input("Enter 'y' to continue, any other key to cancel: ").strip().lower()
+                    if confirm != 'y':
+                        log_info("Deployment cancelled")
+                        return
+                
+                log_info(f"Selected for deployment: {filename}")
+                remote_deploy_tar(filename, service_center_url)
+            else:
+                log_error("Invalid selection")
+                
+        except ValueError:
+            log_error("Please enter a valid number")
+        except KeyboardInterrupt:
+            log_info("\nDeployment cancelled")
+        
+    except requests.exceptions.RequestException as e:
+        log_error(f"Request failed: {str(e)}")
+        log_info(f"Please check if service-center service is running normally and if the URL is correct: {service_center_url}")
+    except Exception as e:
+        log_error(f"Exception occurred while getting tar package list: {str(e)}")

service_forge/sft/cmd/remote_list_tars.py

@@ -0,0 +1,111 @@
+import os
+import json
+import requests
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+from service_forge.sft.config.sft_config import sft_config
+
+def remote_list_tars(service_center_url: str = None) -> None:
+    """
+    Get remote tar package list and status from service-center
+    """
+    # If URL is not provided, try to get it from configuration
+    if not service_center_url:
+        service_center_url = getattr(sft_config, 'service_center_address', 'http://localhost:5000')
+    
+    # Ensure URL ends with /
+    if not service_center_url.endswith('/'):
+        service_center_url += '/'
+    
+    api_url = f"{service_center_url}api/v1/services/tar-list"
+    
+    log_info(f"Getting tar package list from {api_url}...")
+    
+    try:
+        # 发送GET请求
+        response = requests.get(api_url, timeout=30)
+        
+        if response.status_code != 200:
+            log_error(f"Failed to get tar package list, status code: {response.status_code}")
+            try:
+                error_data = response.json()
+                log_error(f"Error message: {error_data.get('message', 'Unknown error')}")
+            except:
+                log_error(f"Response content: {response.text}")
+            return
+        
+        # Parse response data
+        result = response.json()
+        
+        if result.get('code') != 200:
+            log_error(f"Failed to get tar package list: {result.get('message', 'Unknown error')}")
+            return
+        
+        tar_files = result.get('data', [])
+        
+        if not tar_files:
+            log_info("No tar packages found")
+            return
+        
+        # Use rich table to display results
+        console = Console()
+        table = Table(title="Remote Server Tar Package List", show_header=True, header_style="bold magenta")
+        table.add_column("Filename", style="cyan", no_wrap=True)
+        table.add_column("Service Name", style="green", no_wrap=True)
+        table.add_column("Version", style="blue", no_wrap=True)
+        table.add_column("Size", justify="right", style="yellow")
+        table.add_column("Modified Time", style="dim")
+        table.add_column("Deploy Status", justify="center", style="bold")
+        
+        for tar_file in tar_files:
+            # Format file size
+            size = _format_size(tar_file.get('file_size', 0))
+            
+            # Format modification time
+            modified_time = _format_time(tar_file.get('modified_time', 0))
+            
+            # Deployment status
+            deployed_status = "✅ Deployed" if tar_file.get('deployed_status', False) else "❌ Not Deployed"
+            status_style = "green" if tar_file.get('deployed_status', False) else "red"
+            
+            table.add_row(
+                tar_file.get('filename', '-'),
+                tar_file.get('service_name', '-'),
+                tar_file.get('version', '-'),
+                size,
+                modified_time,
+                f"[{status_style}]{deployed_status}[/{status_style}]"
+            )
+        
+        console.print(table)
+        log_success(f"Found {len(tar_files)} tar packages in total")
+        
+    except requests.exceptions.RequestException as e:
+        log_error(f"Request failed: {str(e)}")
+        log_info(f"Please check if service-center service is running normally and if the URL is correct: {service_center_url}")
+    except Exception as e:
+        log_error(f"Exception occurred while getting tar package list: {str(e)}")
+
+def _format_size(size_bytes: int) -> str:
+    """Format file size"""
+    if size_bytes == 0:
+        return "0 B"
+    
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"
+
+def _format_time(timestamp: float) -> str:
+    """Format timestamp"""
+    if timestamp == 0:
+        return "-"
+    
+    try:
+        from datetime import datetime
+        return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+    except:
+        return "-"

service_forge/sft/config/injector.py

@@ -16,6 +16,7 @@ class Injector:
         self.ingress_yaml_path = project_dir / "ingress.yaml"
         self.dockerfile_path = project_dir / "Dockerfile"
         self.pyproject_toml_path = project_dir / "pyproject.toml"
+        self.start_sh_path = project_dir / "start.sh"
         self.metadata = load_metadata(self.metadata_path)
         self.name = self.metadata.name
         self.version = self.metadata.version
@@ -121,9 +122,25 @@ class Injector:
                 f.write(pyproject_toml)
         print("pyproject_toml_path: ", self.pyproject_toml_path)
 
+    def clear_start_sh(self) -> None:
+        if Path(self.start_sh_path).exists():
+            with open(self.start_sh_path, "rb") as f:
+                content = f.read()
+            content_str = content.decode("utf-8")
+            lines = content_str.splitlines()
+            new_content = "\n".join(lines) + ("\n" if content_str.endswith(('\n', '\r')) else "")
+            with open(self.start_sh_path, "w", encoding="utf-8", newline="\n") as f:
+                f.write(new_content)
+
     def inject(self) -> None:
-        self.inject_deployment()
-        self.inject_service_config()
-        self.inject_ingress()
-        self.inject_dockerfile()
-        self.inject_pyproject_toml()
+        if self.metadata.inject.deployment:
+            self.inject_deployment()
+        if self.metadata.inject.service_config:
+            self.inject_service_config()
+        if self.metadata.inject.ingress:
+            self.inject_ingress()
+        if self.metadata.inject.dockerfile:
+            self.inject_dockerfile()
+        if self.metadata.inject.pyproject_toml:
+            self.inject_pyproject_toml()
+        self.clear_start_sh()

service_forge/sft/config/injector_default_files.py

@@ -128,4 +128,4 @@ DEFAULT_PYPROJECT_TOML = """
 
 [tool.uv.sources]
 service-forge = { workspace = true }
-"""
+"""

service_forge/sft/config/sf_metadata.py

@@ -1,30 +1,29 @@
-from omegaconf import OmegaConf
+from __future__ import annotations
+import yaml
+from pydantic import BaseModel
 
-class SfMetadata:
-    def __init__(
-        self,
-        name: str,
-        version: str,
-        description: str,
-        service_config: str,
-        config_only: bool,
-        env: list[dict],
-    ) -> None:
-        self.name = name
-        self.version = version
-        self.description = description
-        self.service_config = service_config
-        self.config_only = config_only
-        self.env = env
+class SfMetadataInject(BaseModel):
+    deployment: bool = True
+    service_config: bool = True
+    ingress: bool = True
+    dockerfile: bool = True
+    pyproject_toml: bool = True
+
+class SfMetadata(BaseModel):
+    name: str
+    version: str
+    description: str
+    service_config: str
+    config_only: bool
+    env: list[dict]
+    inject: SfMetadataInject = SfMetadataInject()
+    enable_auth_middleware: bool = True
+
+    @classmethod
+    def from_yaml_file(cls, filepath: str) -> SfMetadata:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        return cls(**data)
 
 def load_metadata(path: str) -> SfMetadata:
-    with open(path, 'r') as file:
-        data = OmegaConf.load(file)
-        return SfMetadata(
-            name=data.get('name'),
-            version=data.get('version'),
-            description=data.get('description'),
-            service_config=data.get('service_config'),
-            config_only=data.get('config_only'),
-            env=data.get('env', []),
-        )
+    return SfMetadata.from_yaml_file(path)

service_forge/sft/util/assert_util.py

@@ -2,7 +2,6 @@ import typer
 from pathlib import Path
 from typing import Callable, TypeVar, Any
 from service_forge.sft.util.logger import log_error, log_info
-from service_forge.sft.config.sf_metadata import load_metadata, SfMetadata
 
 T = TypeVar('T')
 

service_forge/utils/default_type_converter.py

@@ -2,8 +2,8 @@ from ..utils.type_converter import TypeConverter
 from ..workflow.workflow import Workflow
 from ..api.http_api import fastapi_app
 from ..api.kafka_api import KafkaApp, kafka_app
-from fastapi import FastAPI
 from ..workflow.workflow_type import WorkflowType, workflow_type_register
+from fastapi import FastAPI
 
 type_converter = TypeConverter()
 type_converter.register(str, Workflow, lambda s, node: node.sub_workflows.get_workflow(s))

service_forge/utils/type_converter.py

@@ -1,6 +1,8 @@
 from typing import Any, Callable, Type, Dict, Tuple, Set, List
 from collections import deque
 import inspect
+import traceback
+from pydantic import BaseModel
 from typing_extensions import get_origin, get_args
 
 def is_type(value, dst_type):
@@ -57,6 +59,9 @@ class TypeConverter:
         except Exception:
             pass
 
+        if issubclass(dst_type, BaseModel) and isinstance(value, dict):
+            return dst_type(**value)
+
         path = self._find_path(src_type, dst_type)
         if not path:
             raise TypeError(f"No conversion path found from {src_type.__name__} to {dst_type.__name__}.")

service_forge/utils/workflow_clone.py

@@ -69,6 +69,7 @@ def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) ->
         callbacks=self.callbacks,
         task_id=task_id,
         real_trigger_node=trigger_node,
+        global_context=self.global_context,
     )
 
     for node in workflow.nodes:

service_forge/workflow/node.py

@@ -10,6 +10,7 @@ from .context import Context
 from ..utils.register import Register
 from ..db.database import DatabaseManager, PostgresDatabase, MongoDatabase, RedisDatabase
 from ..utils.workflow_clone import node_clone
+from .workflow_callback import CallbackEvent
 
 if TYPE_CHECKING:
     from .workflow import Workflow
@@ -62,6 +63,10 @@ class Node(ABC):
     def database_manager(self) -> DatabaseManager:
         return self.workflow.database_manager
 
+    @property
+    def global_context(self) -> Context:
+        return self.workflow.global_context
+
     def backup(self) -> None:
         # do NOT use deepcopy here
         # self.bak_context = deepcopy(self.context)
@@ -181,4 +186,7 @@ class Node(ABC):
     def _clone(self, context: Context) -> Node:
         return node_clone(self, context)
 
+    async def stream_output(self, data: Any) -> None:
+         await self.workflow.call_callbacks(CallbackEvent.ON_NODE_STREAM_OUTPUT, node=self, output=data)
+
 node_register = Register[Node]()

service_forge/workflow/triggers/fast_api_trigger.py

@@ -26,6 +26,7 @@ class FastAPITrigger(Trigger):
     DEFAULT_OUTPUT_PORTS = [
         Port("trigger", bool),
         Port("user_id", int),
+        Port("token", str),
         Port("data", Any),
     ]
 
@@ -72,6 +73,7 @@ class FastAPITrigger(Trigger):
         self.trigger_queue.put_nowait({
             "id": task_id,
             "user_id": getattr(request.state, "user_id", None),
+            "token": getattr(request.state, "auth_token", None),
             "data": converted_data,
         })
 
@@ -169,6 +171,7 @@ class FastAPITrigger(Trigger):
             try:
                 trigger = await self.trigger_queue.get()
                 self.prepare_output_edges(self.get_output_port_by_name('user_id'), trigger['user_id'])
+                self.prepare_output_edges(self.get_output_port_by_name('token'), trigger['token'])
                 self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
                 yield self.trigger(trigger['id'])
             except Exception as e:

service_forge/workflow/triggers/websocket_api_trigger.py

@@ -9,6 +9,7 @@ from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from service_forge.workflow.port import Port
 from google.protobuf.message import Message
 from google.protobuf.json_format import MessageToJson
+from service_forge.api.http_api import authenticate_websocket
 
 class WebSocketAPITrigger(Trigger):
     DEFAULT_INPUT_PORTS = [
@@ -19,6 +20,8 @@ class WebSocketAPITrigger(Trigger):
 
     DEFAULT_OUTPUT_PORTS = [
         Port("trigger", bool),
+        Port("user_id", int),
+        Port("token", str),
         Port("data", Any),
     ]
 
@@ -36,6 +39,20 @@ class WebSocketAPITrigger(Trigger):
             )
         return result
 
+    async def send_message(
+        self,
+        websocket: WebSocket,
+        type: str,
+        task_id: uuid.UUID,
+        data: Any,
+    ):
+        message = {
+            "type": type,
+            "task_id": str(task_id),
+            "data": data
+        }
+        await websocket.send_text(json.dumps(message))
+
     async def handle_stream_output(
         self,
         websocket: WebSocket,
@@ -46,12 +63,7 @@ class WebSocketAPITrigger(Trigger):
                 item = await self.stream_queues[task_id].get()
 
                 if item.is_error:
-                    error_response = {
-                        "type": "stream_error",
-                        "task_id": str(task_id),
-                        "detail": str(item.result)
-                    }
-                    await websocket.send_text(json.dumps(error_response))
+                    await self.send_message(websocket, "stream_error", task_id, str(item.result))
                     break
                 
                 if item.is_end:
@@ -65,18 +77,9 @@ class WebSocketAPITrigger(Trigger):
                                 data = serialized
                         else:
                             data = serialized
-                        
-                        end_response = {
-                            "type": "stream_end",
-                            "task_id": str(task_id),
-                            "data": data
-                        }
+                        await self.send_message(websocket, "stream_end", task_id, data)
                     else:
-                        end_response = {
-                            "type": "stream_end",
-                            "task_id": str(task_id)
-                        }
-                    await websocket.send_text(json.dumps(end_response))
+                        await self.send_message(websocket, "stream_end", task_id, None)
                     break
 
                 # Send stream data
@@ -89,23 +92,10 @@ class WebSocketAPITrigger(Trigger):
                 else:
                     data = serialized
                 
-                stream_response = {
-                    "type": "stream",
-                    "task_id": str(task_id),
-                    "data": data
-                }
-                await websocket.send_text(json.dumps(stream_response))
+                await self.send_message(websocket, "stream", task_id, data)
         except Exception as e:
             logger.error(f"Error handling stream output for task {task_id}: {e}")
-            error_response = {
-                "type": "stream_error",
-                "task_id": str(task_id),
-                "detail": str(e)
-            }
-            try:
-                await websocket.send_text(json.dumps(error_response))
-            except Exception:
-                pass
+            await self.send_message(websocket, "stream_error", task_id, str(e))
         finally:
             if task_id in self.stream_queues:
                 del self.stream_queues[task_id]
@@ -120,10 +110,13 @@ class WebSocketAPITrigger(Trigger):
         self.result_queues[task_id] = asyncio.Queue()
         self.stream_queues[task_id] = asyncio.Queue()
 
+        logger.info(f'user_id {getattr(websocket.state, "user_id", None)} token {getattr(websocket.state, "auth_token", None)}')
+
         if data_type is Any:
             converted_data = message_data
         else:
             try:
+                # TODO: message_data is Message, need to convert to dict
                 converted_data = data_type(**message_data)
             except Exception as e:
                 error_msg = {"error": f"Failed to convert data: {str(e)}"}
@@ -135,6 +128,8 @@ class WebSocketAPITrigger(Trigger):
 
         self.trigger_queue.put_nowait({
             "id": task_id,
+            "user_id": getattr(websocket.state, "user_id", None),
+            "token": getattr(websocket.state, "auth_token", None),
             "data": converted_data,
         })
 
@@ -142,20 +137,30 @@ class WebSocketAPITrigger(Trigger):
 
     def _setup_websocket(self, app: FastAPI, path: str, data_type: type) -> None:
         async def websocket_handler(websocket: WebSocket):
+            # Authenticate WebSocket connection before accepting
+            # Get trusted_domain from app.state if available
+            trusted_domain = getattr(app.state, "trusted_domain", "ring.shiweinan.com")
+            enable_auth = getattr(app.state, "enable_auth_middleware", True)
+            
+            if enable_auth:
+                await authenticate_websocket(websocket, trusted_domain)
+            else:
+                # If auth is disabled, set default values
+                websocket.state.user_id = websocket.headers.get("X-User-ID", "0")
+                websocket.state.auth_token = websocket.headers.get("X-User-Token")
+            
             await websocket.accept()
             
             try:
                 while True:
-                    # Receive message from client
-                    data = await websocket.receive_text()
+                    data = await websocket.receive()
                     try:
-                        message = json.loads(data)
-                        
+                        # message = json.loads(data)
                         # Handle the message and trigger workflow
                         await self.handle_websocket_message(
                             websocket,
                             data_type,
-                            message
+                            data
                         )
                     except json.JSONDecodeError:
                         error_msg = {"error": "Invalid JSON format"}
@@ -179,6 +184,8 @@ class WebSocketAPITrigger(Trigger):
         while True:
             try:
                 trigger = await self.trigger_queue.get()
+                self.prepare_output_edges(self.get_output_port_by_name('user_id'), trigger['user_id'])
+                self.prepare_output_edges(self.get_output_port_by_name('token'), trigger['token'])
                 self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
                 yield self.trigger(trigger['id'])
             except Exception as e:

service_forge/workflow/workflow.py

@@ -13,6 +13,7 @@ from ..db.database import DatabaseManager
 from ..utils.workflow_clone import workflow_clone
 from .workflow_callback import WorkflowCallback, BuiltinWorkflowCallback, CallbackEvent
 from .workflow_config import WorkflowConfig
+from .context import Context
 
 class Workflow:
     def __init__(
@@ -31,6 +32,9 @@ class Workflow:
         # for run
         task_id: uuid.UUID = None,
         real_trigger_node: Trigger = None,
+
+        # global variables
+        global_context: Context = None,
     ) -> None:
         self.id = id
         self.config = config
@@ -48,6 +52,7 @@ class Workflow:
         self.callbacks = callbacks
         self.task_id = task_id
         self.real_trigger_node = real_trigger_node
+        self.global_context = global_context
         self._validate()
     
     @property
@@ -74,6 +79,8 @@ class Workflow:
                 await callback.on_workflow_start(*args, **kwargs)
             elif callback_type == CallbackEvent.ON_WORKFLOW_END:
                 await callback.on_workflow_end(*args, **kwargs)
+            elif callback_type == CallbackEvent.ON_WORKFLOW_ERROR:
+                await callback.on_workflow_error(*args, **kwargs)
             elif callback_type == CallbackEvent.ON_NODE_START:
                 await callback.on_node_start(*args, **kwargs)
             elif callback_type == CallbackEvent.ON_NODE_END:
@@ -117,7 +124,7 @@ class Workflow:
             raise ValueError("Multiple trigger nodes found in workflow.")
         return trigger_nodes[0]
 
-    async def _run_node_with_callbacks(self, node: Node) -> None:
+    async def _run_node_with_callbacks(self, node: Node) -> bool:
         await self.call_callbacks(CallbackEvent.ON_NODE_START, node=node)
         
         try:
@@ -126,8 +133,13 @@ class Workflow:
                 await self.handle_node_stream_output(node, result)
             elif asyncio.iscoroutine(result):
                 await result
+        except Exception as e:
+            await self.call_callbacks(CallbackEvent.ON_WORKFLOW_ERROR, workflow=self, node=node, error=e)
+            logger.error(f"Error when running node {node.name}: {str(e)}, task_id: {self.task_id}")
+            return False
         finally:
             await self.call_callbacks(CallbackEvent.ON_NODE_END, node=node)
+        return True
 
     async def run_after_trigger(self) -> Any:
         logger.info(f"Running workflow: {self.name}")
@@ -138,30 +150,41 @@ class Workflow:
         for edge in self.get_trigger_node().output_edges:
             edge.end_port.trigger()
 
-        try:
-            for input_port in self.input_ports:
-                if input_port.value is not None:
-                    input_port.port.node.fill_input(input_port.port, input_port.value)
-
-            for node in self.nodes:
-                for key in node.AUTO_FILL_INPUT_PORTS:
-                    if key[0] not in [edge.end_port.name for edge in node.input_edges]:
-                        node.fill_input_by_name(key[0], key[1])
-
-            while self.ready_nodes:
-                nodes = self.ready_nodes.copy()
-                self.ready_nodes = []
-
-                tasks = []
-                for node in nodes:
-                    tasks.append(asyncio.create_task(self._run_node_with_callbacks(node)))
-
-                await asyncio.gather(*tasks)
-
-        except Exception as e:
-            error_msg = f"Error in run_after_trigger: {str(e)}"
-            logger.error(error_msg)
-            raise e
+        for input_port in self.input_ports:
+            if input_port.value is not None:
+                input_port.port.node.fill_input(input_port.port, input_port.value)
+
+        for node in self.nodes:
+            for key in node.AUTO_FILL_INPUT_PORTS:
+                if key[0] not in [edge.end_port.name for edge in node.input_edges]:
+                    node.fill_input_by_name(key[0], key[1])
+
+        while self.ready_nodes:
+            nodes = self.ready_nodes.copy()
+            self.ready_nodes = []
+
+            tasks = []
+            for node in nodes:
+                tasks.append(asyncio.create_task(self._run_node_with_callbacks(node)))
+
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            for i, result in enumerate(results):
+                if isinstance(result, Exception):
+                    for task in tasks:
+                        if not task.done():
+                            task.cancel()
+                    await asyncio.gather(*tasks, return_exceptions=True)
+                    return
+                    # raise result
+                elif result is False:
+                    logger.error(f"Node execution failed, stopping workflow: {nodes[i].name}")
+                    for task in tasks:
+                        if not task.done():
+                            task.cancel()
+                    await asyncio.gather(*tasks, return_exceptions=True)
+                    return
+                    # raise RuntimeError(f"Workflow stopped due to node execution failure: {nodes[i].name}")
 
         if len(self.output_ports) > 0:
             if len(self.output_ports) == 1:
@@ -186,8 +209,11 @@ class Workflow:
                 # TODO: clear new_workflow
 
             except Exception as e:
-                error_msg = f"Error running workflow: {str(e)}, {traceback.format_exc()}"
-                logger.error(error_msg)
+                await self.call_callbacks(CallbackEvent.ON_WORKFLOW_ERROR, workflow=self, node=None, error=e)
+                # error_msg = f"Error running workflow: {str(e)}, {traceback.format_exc()}"
+                # logger.error(error_msg)
+                # await self.call_callbacks(CallbackEvent.ON_WORKFLOW_END, workflow=self, node=None, error=e)
+                return
 
     async def run(self):
         tasks = []

service_forge/workflow/workflow_callback.py

@@ -31,7 +31,7 @@ class WorkflowCallback:
         pass
 
     @abstractmethod
-    async def on_workflow_error(self, workflow: Workflow, error: Any) -> None:
+    async def on_workflow_error(self, workflow: Workflow, node: Node, error: Any) -> None:
         pass
 
     @abstractmethod
@@ -90,7 +90,7 @@ class BuiltinWorkflowCallback(WorkflowCallback):
             logger.error(f"发送 workflow_end 消息到 websocket 失败: {e}")
 
     @override
-    async def on_workflow_error(self, workflow: Workflow, error: Any) -> None:
+    async def on_workflow_error(self, workflow: Workflow, node: Node | None, error: Any) -> None:
         workflow_result = WorkflowResult(result=error, is_end=False, is_error=True)
         
         if workflow.task_id in workflow.real_trigger_node.result_queues:
@@ -103,6 +103,7 @@ class BuiltinWorkflowCallback(WorkflowCallback):
             message = {
                 "type": "workflow_error",
                 "task_id": str(workflow.task_id),
+                "node": node.name if node else None,
                 "error": self._serialize_result(error),
                 "is_end": False,
                 "is_error": True

service_forge/workflow/workflow_factory.py

@@ -71,6 +71,7 @@ def create_workflow(
         database_manager = database_manager,
         # TODO: max_concurrent_runs
         callbacks = [BuiltinWorkflowCallback()],
+        global_context = Context(variables={}),
     )
 
     nodes: dict[str, Node] = {}

{service_forge-0.1.18.dist-info → service_forge-0.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: service-forge
-Version: 0.1.18
+Version: 0.1.28
 Summary: Add your description here
 Author-email: euxcet <zcc.qwer@gmail.com>
 Requires-Python: >=3.11

{service_forge-0.1.18.dist-info → service_forge-0.1.28.dist-info}/RECORD

@@ -1,18 +1,18 @@
 service_forge/current_service.py,sha256=0YKm7nQiXzUUAc1ToCcbG1QPJfOSNKcOHUpyJ4E3xrY,342
-service_forge/service.py,sha256=rZZ7-BXTTCrc6KqnONnKpg-bRs5JCfDTvMrl4K26vbE,12633
+service_forge/service.py,sha256=lHsZraEH6Ze20QO5v6iW1MO8src8T8JKLFRBXtd0LD0,12933
 service_forge/service_config.py,sha256=zsTdCZ1peMAotjGEVypPos7d-gjwrYoB9x_12g95G4g,1242
 service_forge/api/deprecated_websocket_api.py,sha256=E36-fpUPxzMJ2YGlCPeqwRbryk2FMMbQD_pbb8k1FYI,3343
 service_forge/api/deprecated_websocket_manager.py,sha256=Xiwg3zwXRVi63sXmVH-TgbpL2XH_djyLeo96STm4cNM,16757
-service_forge/api/http_api.py,sha256=XnEQ45zuWQV1zrSL9vd3USUh47ymkVc4w_1SoFlNdl8,5648
+service_forge/api/http_api.py,sha256=8vcN7oyxwTwu_w1f-Egh2XrFWsm-ci5_gk7KsQiP1iM,7673
 service_forge/api/http_api_doc.py,sha256=ASlxvsIiUzDcMhVoumRjt9CfEMbh0O1U4ZLC9eobLF8,20235
 service_forge/api/kafka_api.py,sha256=PInx2ZzKJRON7EaJFWroXkiOt_UeZY7WE6qK03gq4ak,4599
 service_forge/api/task_manager.py,sha256=9Lk-NV4cBnuv9b8V6GVLWJJ4MCiAwCp5TVAwmYgqXbs,5269
 service_forge/api/routers/feedback/feedback_router.py,sha256=JOJI6kaQYapg4__iA6Eo26_9su48p7R2Kpn422nbsxw,5640
 service_forge/api/routers/service/service_router.py,sha256=hGOT-ScnXR7agHp-F9OFGWiPFjG9f3gl7NBsnayW3JI,5088
 service_forge/api/routers/websocket/websocket_manager.py,sha256=j1AFqzXQhZZyaLQwhvZefXAS-zCOPzLcRMDEuusv6V0,3605
-service_forge/api/routers/websocket/websocket_router.py,sha256=V0B7eQP8toO94-WbTrGraadXD3qeZ9lnKFcxwx6kLgM,3777
+service_forge/api/routers/websocket/websocket_router.py,sha256=sPDJriEpD2mqu4508cOaWK7u040sgOdaUFlyiBqCSgc,4447
 service_forge/db/__init__.py,sha256=EWLhH8bYsMOvRF_YXF6FgL3irKA6GZeLxSGvWDRM6f8,85
-service_forge/db/database.py,sha256=IdF7RV-bOFmPPu7d4sQFtsF3e8mZKwMXUkMi7HPEPnc,9329
+service_forge/db/database.py,sha256=WKtZ0MoOnbMw54ohfs9zKsrOZ5_qenLvXkAV_Gr2WOs,10068
 service_forge/db/migrations/feedback_migration.py,sha256=-zQ71TsOlWmQPQo1NKSIu3C1T47v3cfD6IAQ5HE_ffk,4845
 service_forge/db/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_forge/db/models/feedback.py,sha256=gltX3y-nNhXSR9z1cd82Vg-zwjF0JhnGbOvUapkcWKQ,1253
@@ -22,42 +22,44 @@ service_forge/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 service_forge/model/feedback.py,sha256=Is5tkplzYkjChGb67o-Qjtbu4kSspVuaKi4Aua_QdRo,1318
 service_forge/model/websocket.py,sha256=YIUCW32sbHIEFPHjk5FiDM_rDe2aVD6OpzBQul2R5IM,267
 service_forge/proto/foo_input.py,sha256=-POJZSIFrGdBGz7FqZZ03r5uztpc5Apin9A0Yxbk6YI,90
-service_forge/sft/cli.py,sha256=stB_YPhZ7gAQeOxIq03-tLyl5VfU-gnRacAT05GSMis,2904
+service_forge/sft/cli.py,sha256=xcM6kiGPJeHEUqfJd4uFngVFpjfVkDxW4G_PbNRD9Xs,4265
 service_forge/sft/cmd/config_command.py,sha256=I9t2HG28S6lCXpExHyZUc47b_1yB3i51tCFVk5J6TTU,2382
 service_forge/sft/cmd/deploy_service.py,sha256=5IYbCVI0Nlry1KXBhm9leJmr2bzUEXrSY-2BympLR0c,4686
 service_forge/sft/cmd/list_tars.py,sha256=Z3zvu2JLb_wNbTwi5TZXL5cZ8PxYrKks9AxkOzoUd_Q,1380
+service_forge/sft/cmd/remote_deploy.py,sha256=AStAlbqGD7XeZFhL0fx2j12YWP_MVbdURbO5ZENEMgc,6510
+service_forge/sft/cmd/remote_list_tars.py,sha256=mx6hkNnu0ySMyBX2Qi6blKMj5xnNnrmXq3VD_nERlmw,4176
 service_forge/sft/cmd/service_command.py,sha256=69GMMN61KtuoEFuYzFJ74ivNt8RX8q0I6rbePfJfEwQ,5538
 service_forge/sft/cmd/upload_service.py,sha256=86PvvJSXCZKH4BU6rLytuc45grX-sRnQnOHCo9zUaPY,1232
-service_forge/sft/config/injector.py,sha256=El8U5USveKfC0-jhhqYgaevjp4R4fwW02oMvDn7Amyk,5762
-service_forge/sft/config/injector_default_files.py,sha256=aTMQ2Tla3wdpvdaD_5VP2X6oeZbI0X414FM9NbirnO4,2716
-service_forge/sft/config/sf_metadata.py,sha256=Y9akhSCgOd11-oqRs3LIs8FL9pvWNw6hyy57fuFcBhc,866
+service_forge/sft/config/injector.py,sha256=V79AW1W_LyU-Hn2QgJlLyTt8tdI3J1t1jS3wRoXfbSo,6581
+service_forge/sft/config/injector_default_files.py,sha256=f7mNJ5Y9yb4e9kjLn414WiQoZrOue9ok_hq_POG4I2o,2717
+service_forge/sft/config/sf_metadata.py,sha256=RruOe3_6JdxLnzMbmdnOcncxwnmATR-1q3Cn8R9d5eE,782
 service_forge/sft/config/sft_config.py,sha256=MgurtgbcSmyXbGlVX3NG84KD4Hst1gZWHdF9a8zi-6U,7707
 service_forge/sft/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_forge/sft/file/ignore_pattern.py,sha256=UrVmR83wOx51XHFcZDTPp15dGYcvMTE5W1m07-SvHpw,2521
 service_forge/sft/file/sft_file_manager.py,sha256=poIM77tZZg7vfwBdCsdQctBbCczVLQePdTwVINEABvE,4337
 service_forge/sft/kubernetes/kubernetes_manager.py,sha256=IF2_X9U-k5Dx7EZuGrJ9lZ85ltbilrrZDfsl8qFyTu4,11339
-service_forge/sft/util/assert_util.py,sha256=8HreVkOzs9_ClKiFqG4qsFn_yyDLo5uXYhYUPXlmDjM,828
+service_forge/sft/util/assert_util.py,sha256=6XVTsXKxg92ww3heWzuMvTbybGuw1cmTqWqfiSbPAcY,753
 service_forge/sft/util/logger.py,sha256=0Hi74IoxshE-wBgvBa2EZPXYj37tTrUYwlOBd9UMMMs,502
 service_forge/sft/util/name_util.py,sha256=WSYHM6c7SZULXCFON7nmGqsvAPPs_wavd6QjCa4UbRQ,301
 service_forge/sft/util/yaml_utils.py,sha256=9OhJNQlzj_C1NeQoUZVF8qpDovrE7RDWtNXe-H7tuNA,1703
 service_forge/storage/__init__.py,sha256=8Jg4R9z2JHadheV1YrHtCsFxEL5aCl9n2dMQGHcJfvM,156
 service_forge/storage/feedback_storage.py,sha256=wnuNTmEzpnS7iisiU9MrEJIgVa2G_HysqICWk_PxzfU,9124
 service_forge/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-service_forge/utils/default_type_converter.py,sha256=CuUZpMATdTwgcV1M3lbK64znwmEG85Zt3y_QGXr9tYQ,625
+service_forge/utils/default_type_converter.py,sha256=KFWhlZJUrQc2e-Wm9-WfPUKp5UaI-fpVjzNLO6n37e8,625
 service_forge/utils/register.py,sha256=nxiGQBCX238FoZZhsDoDdBMv_2QzeIZpM367HPNfaqM,874
-service_forge/utils/type_converter.py,sha256=IRphYxyGA0ICwFvDMvqAnRnSUTpY2ZQXvTE5o99CKpo,3046
-service_forge/utils/workflow_clone.py,sha256=I3qNmJLbhAbKb-5VITls89pMmGcWNtI64IOTxN-PUwY,4549
+service_forge/utils/type_converter.py,sha256=eGAAnqEr-va1PBwYOzuzzzExVJNtusn-yGRv7i9WjRY,3204
+service_forge/utils/workflow_clone.py,sha256=K2Y4XXsGYQn4OTKcDYEa7UZHGXta_hztKW-pr4EYaDQ,4593
 service_forge/workflow/__init__.py,sha256=9oh4qPyA33RugrUYRAlLmFtmQPUN2wxruFQE3omTJF8,49
 service_forge/workflow/context.py,sha256=1PotSEN_l8Emd5p8_6mtXJngXGYd3NSbOs1EKHgvnlo,346
 service_forge/workflow/edge.py,sha256=88Ex-9_dHAGD38OHgiqP0DrfxK0FrhvDAxThR3ilUi4,627
-service_forge/workflow/node.py,sha256=jPzXuixmZBL6-_jjXikFZmierlu3SOBJOSdQxTyV0FY,7536
+service_forge/workflow/node.py,sha256=hoO8TdfbB5inpu55YCwecnasi4RS-Bg9R8Sp-M5c2Ys,7841
 service_forge/workflow/port.py,sha256=JVj0JrnQeOWCsp7n48Cm03bfmO8r3V5oTSEsC-HTGPE,2967
 service_forge/workflow/trigger.py,sha256=2OqiHi0dFcoC8g5GDqVpVEpHKlmqtDADb74Z7PRzHlo,879
-service_forge/workflow/workflow.py,sha256=ykPZBN0sLrORnM83AErcLmFTdUjF5gvbNuMAnY_-p00,8332
-service_forge/workflow/workflow_callback.py,sha256=S__F7s-7l5LgkIXcZMcG68qCyc8NgdWQX81F0hKWL1U,5135
+service_forge/workflow/workflow.py,sha256=YsA_Yeh5XjYQflztqKWoWBt9euEoHVOJMGMTquIoO04,9788
+service_forge/workflow/workflow_callback.py,sha256=MJBG_DTQGCgqCjpnBhuSteZmOxitYRdtkxXlFCOh930,5219
 service_forge/workflow/workflow_config.py,sha256=Yih10b-utKIpaR-X-nfy7fPnmBNhRvlD8Bw2_mQ5lJI,1821
 service_forge/workflow/workflow_event.py,sha256=QG1VFJwUUF1bTKKPKvqBICnYxkBwpfYDEoAuxwQYhhE,371
-service_forge/workflow/workflow_factory.py,sha256=AV39dK2QmG1ed9Mm3BXGI3s-w-o3PuMnwU-Y6VyAVFk,9885
+service_forge/workflow/workflow_factory.py,sha256=KfIxjdQhsRC0KYrEkAhqlx3oY6tABoulQGhBwBBXLq0,9933
 service_forge/workflow/workflow_group.py,sha256=c-Hcfb-nVKxCVddoEQNFV6nY4LVAku0iq7tTUef9fDM,2076
 service_forge/workflow/workflow_type.py,sha256=zRc-gL2LBE-gOgTUCU5-VDWeGUzuQahkHIg98ipEvQg,1629
 service_forge/workflow/nodes/__init__.py,sha256=AUOoFUAMgRwfLiHNkjnDnWToMSe2AeV5vJO3NCG1eLw,381
@@ -72,12 +74,12 @@ service_forge/workflow/nodes/test/if_console_input_node.py,sha256=CtKHkFqr8PN974
 service_forge/workflow/nodes/test/time_consuming_node.py,sha256=gB2qw2DdjRf82z1158u36nSnCHrheHaxscAzPRnXNyk,1813
 service_forge/workflow/triggers/__init__.py,sha256=iQ0WEYu6JgL191Y9XslMhZ7jS7JO8bL3SZ9YqIw5LCM,269
 service_forge/workflow/triggers/a2a_api_trigger.py,sha256=Oaw3vRLA8fWZUIQ-h33dYmojmjp4mwNF_0LHqQ_4mZQ,8583
-service_forge/workflow/triggers/fast_api_trigger.py,sha256=8BF0A8gdcKeiP3cyF_dF0T3MH7bXnnZRCa_h5hx9kQ4,7513
+service_forge/workflow/triggers/fast_api_trigger.py,sha256=bAtnuNkUcB5rApXj7x3oBscdavUnDGTb7lE9OpmtauE,7705
 service_forge/workflow/triggers/kafka_api_trigger.py,sha256=Zv8J75Rmg1-xqxHwpBMBhsm_TWX8p3_rqldk2RVSwVc,1561
 service_forge/workflow/triggers/once_trigger.py,sha256=YmzSQBoKE-8liNFIoDCqi2UdqhHujizsXVDft81_8jA,572
 service_forge/workflow/triggers/period_trigger.py,sha256=JFX3yBjKqoRP55jiulaSG_SPO-zWLMcwEb1BwcKsWUM,767
-service_forge/workflow/triggers/websocket_api_trigger.py,sha256=DRVFVdR3NgUx8S6Rlv492_3xrmlNGDOcvUrz13jHQ7o,6902
-service_forge-0.1.18.dist-info/METADATA,sha256=dP-GKlnX6P32jvP-1oudgM_Rj760sCCf6fayQf9FvuY,2308
-service_forge-0.1.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-service_forge-0.1.18.dist-info/entry_points.txt,sha256=WHntHW7GAyKQUEeMcMvHDZ7_xAb0-cZeAK4iJeu9lm8,51
-service_forge-0.1.18.dist-info/RECORD,,
+service_forge/workflow/triggers/websocket_api_trigger.py,sha256=gmO3ie2ctXOpZ3LIMXpp8AQ9I2Bo3l2IBkvxH9zFh5s,7588
+service_forge-0.1.28.dist-info/METADATA,sha256=8HUAOLGWFRFgOaztY6wsCa9kWD-v1aJlNYSAWBoBmGs,2308
+service_forge-0.1.28.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+service_forge-0.1.28.dist-info/entry_points.txt,sha256=WHntHW7GAyKQUEeMcMvHDZ7_xAb0-cZeAK4iJeu9lm8,51
+service_forge-0.1.28.dist-info/RECORD,,