ibm-watsonx-orchestrate 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

ibm_watsonx_orchestrate/docker/default.env

@@ -46,38 +46,46 @@ CELERY_RESULTS_TTL="3600"
 EVENT_BROKER_TTL="-1"
 
 # START -- IMAGE REGISTRIES AND TAGS
-# THE VALUES FOR REGISTRY_URL AND *_REGISTRY ARE NOT SET HERE; THEY ARE EITHER PROVIDED BY THE USER OR DETERMINED AT RUNTIME BASED ON WO_DEVELOPER_EDITION_SOURCE.
+# The registry URL to pull the private images from, including the name of the repository in the registry.
+# e.g. cp.icr.io/cp/wxo-lite
+# If the registry URL is not set here or by the user, then it will be set automatically based on the value of WO_DEVELOPER_EDITION_SOURCE
+# The *_REGISTRY variables are used to set the registry URL for each component. If not set, the URL here will be used.
+# See get_default_registry_env_vars_by_dev_edition_source() in src/ibm_watsonx_orchestrate/cli/commands/server/server_command.py for more details.
 REGISTRY_URL=
 
-SERVER_TAG=06-05-2025
+SERVER_TAG=30-05-2025
 SERVER_REGISTRY=
 
-WORKER_TAG=06-05-2025
+WORKER_TAG=30-05-2025
 WORKER_REGISTRY=
 
+AI_GATEWAY_TAG=30-05-2025
+AI_GATEWAY_REGISTRY=
+
 DB_REGISTRY=
 # If you build multiarch set all three of these to the same, we have a pr against main
 # to not have this separation, but we can merge it later
-DBTAG=02-05-2025
-AMDDBTAG=02-05-2025
-ARM64DBTAG=02-05-2025
+DBTAG=30-05-2025
+AMDDBTAG=30-05-2025
+ARM64DBTAG=30-05-2025
 
 UI_REGISTRY=
-UITAG=01-05-2025
+UITAG=23-05-2025
 
 CM_REGISTRY=
-CM_TAG=30-04-2025
+CM_TAG=13-05-2025
 
-TRM_TAG=02-05-2025
+TRM_TAG=25-05-2025
 TRM_REGISTRY=
 
-TR_TAG=02-05-2025
+TR_TAG=25-05-2025
 TR_REGISTRY=
 
+BUILDER_TAG=27-05-2025
 BUILDER_REGISTRY=
-BUILDER_TAG=02-05-2025
 
-FLOW_RUNTIME_TAG=31-03-2025
+
+FLOW_RUNTIME_TAG=13-05-2025
 FLOW_RUMTIME_REGISTRY=
 
 # END -- IMAGE REGISTRIES AND TAGS
@@ -110,6 +118,8 @@ WXO_BASE_URL=http://wxo-server:4321
 RUNTIME_MANAGER_API_KEY="testapikey"
 TOOLS_RUNTIME_MANAGER_BASE_URL="http://tools-runtime-manager:8080"
 CONNECTION_SERVICE_BASE_URL="http://wxo-server-connection-manager:3001"
+AI_GATEWAY_BASE_URL="http://ai-gateway:8787/v1"
+AI_GATEWAY_ENABLED=True
 
 #To Prevent warnings
 VECTOR_STORE_PROVIDER=

ibm_watsonx_orchestrate/docker/tempus/common-config.yaml

@@ -1 +1 @@
-NODE_LOG_LEVEL: trace
+NODE_LOG_LEVEL: audit

ibm_watsonx_orchestrate/experimental/flow_builder/data_map.py

@@ -0,0 +1,19 @@
+from typing import Any, Optional, Self
+from pydantic import BaseModel, Field, SerializeAsAny
+
+from .types import (
+    Assignment
+)
+
+
+class DataMap(BaseModel):
+    maps: Optional[list[Assignment]] = Field(default_factory=list)
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        if self.maps and len(self.maps) > 0:
+            model_spec["maps"] = [assignment.model_dump() for assignment in self.maps]
+
+    def add(self, line: Assignment) -> Self:
+        self.maps.append(line)
+

ibm_watsonx_orchestrate/experimental/flow_builder/flows/__init__.py

@@ -0,0 +1,42 @@
+from .constants import START, END, RESERVED
+from ..types import FlowContext, TaskData, TaskEventType
+from ..node import UserNode, AgentNode, StartNode, EndNode, PromptNode
+from .flow import Flow, CompiledFlow, FlowRun, FlowEvent, FlowEventType, FlowFactory, MatchPolicy, WaitPolicy, ForeachPolicy, Branch, Foreach, Loop
+from .decorators import user, flow_spec, flow
+from ..data_map import Assignment, DataMap
+
+
+__all__ = [
+    "START",
+    "END",
+    "RESERVED",
+
+    "FlowContext",
+    "TaskData",
+    "TaskEventType",
+
+    "UserNode",
+    "AgentNode",
+    "StartNode",
+    "EndNode",
+    "PromptNode",
+    "Assignment",
+    "DataMap",
+
+    "Flow",    
+    "CompiledFlow",
+    "FlowRun",
+    "FlowEvent",
+    "FlowEventType",
+    "FlowFactory",
+    "MatchPolicy",
+    "WaitPolicy",
+    "ForeachPolicy",
+    "Branch",
+    "Foreach",
+    "Loop",
+
+    "user",
+    "flow_spec",
+    "flow"
+]

ibm_watsonx_orchestrate/experimental/flow_builder/flows/constants.py

@@ -0,0 +1,19 @@
+"""
+Predefined constants for Flow.
+"""
+import sys
+
+START = sys.intern("__start__")
+END = sys.intern("__end__")
+
+ANY_USER = sys.intern("__any_user__")
+CURRENT_USER = sys.intern("__current_user__")
+FLOW_CONTEXT = sys.intern("FlowContext")
+
+RESERVED = {
+    START,
+    END,
+    FLOW_CONTEXT,
+    ANY_USER,
+    CURRENT_USER
+}

ibm_watsonx_orchestrate/experimental/flow_builder/flows/decorators.py

@@ -0,0 +1,144 @@
+"""
+A set of decorators to help define different Flow constructs.
+"""
+
+import asyncio
+from functools import wraps
+import logging
+import inspect
+from typing import Callable, Optional, Sequence
+from pydantic import BaseModel
+from ..types import extract_node_spec, UserNodeSpec, FlowSpec
+
+from .flow import FlowFactory, Flow
+
+logger = logging.getLogger(__name__)
+
+
+class FlowWrapper:
+    def __init__(self, func, a_model):
+        self.func = func
+        self.a_model = a_model
+        wraps(func)(self)  # Preserve metadata
+
+    def __call__(self, *args, **kwargs):
+        result = self.func(self.a_model)
+        if not isinstance(result, Flow):
+            raise ValueError("Return value must be of type Flow")
+        return result
+    
+def user(*args, name: str|None=None, description: str|None=None, owners: Sequence[str]|None = None, message: str | None = None):
+    """Decorator to mark a function as a user node specification."""
+
+    def decorator(func: Callable):
+        node_spec = extract_node_spec(func, name, description)
+        func.__user_spec__ = UserNodeSpec(type = "user",
+                                          name = node_spec.name,
+                                          display_name = node_spec.display_name,
+                                          description = node_spec.description,
+                                          input_schema = node_spec.input_schema,
+                                          output_schema = node_spec.output_schema,
+                                          output_schema_object = node_spec.output_schema_object,
+                                          text=message,
+                                          owners=owners)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            logger.error(f"User node {name} is not supported yet.")            
+            r = func(*args, **kwargs)
+            return r
+
+        return wrapper
+
+    if len(args) == 1 and callable(args[0]):
+        return decorator(args[0])
+    else:
+        return decorator
+
+
+def flow_spec(*args,
+              name: Optional[str]=None,
+              description: str|None=None,
+              initiators: Sequence[str] = ()):
+    """Decorator to mark a function as a flow specification."""
+
+    def decorator(func: Callable):
+        node_spec = extract_node_spec(func, name, description)
+        a_spec = FlowSpec(type = "flow",
+                             name = node_spec.name,
+                             display_name = node_spec.display_name,
+                             description = node_spec.description,
+                             input_schema = node_spec.input_schema,
+                             output_schema = node_spec.output_schema,
+                             output_schema_object = node_spec.output_schema_object,
+                             initiators = initiators)
+
+        # we should also check a flow is async
+        if not asyncio.iscoroutinefunction(func):
+            raise ValueError("Flow must be asynchronous.")
+
+        logger.info("Generated flow spec: %s", a_spec)
+        func.__flow_spec__ = a_spec
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            logger.info("Creating flow spec: %s", name)
+            r = func(*args, **kwargs)
+            logger.info("Flow spec %s returned: %s", name, r)
+            return r
+
+        return wrapper
+
+    if len(args) == 1 and callable(args[0]):
+        return decorator(args[0])
+    else:
+        return decorator
+    
+def flow(*args, 
+         name: Optional[str]=None, 
+         display_name: Optional[str]=None,
+         description: str|None=None,
+         input_schema: type[BaseModel] | None = None,
+         output_schema: type[BaseModel] | None = None,
+         initiators: Sequence[str] = ()):
+    """Decorator to mark a function as a flow model builder."""
+
+    def decorator(func: Callable):
+        """
+        Decorator that takes a function as an argument and returns a wrapper function.
+        The wrapper function takes a single argument of type Flow and calls the original function with the created flow as an argument.
+        """
+
+        sig = inspect.signature(func)
+        if len(sig.parameters) != 1:
+            raise ValueError("Only one argument is allowed")
+        param = list(sig.parameters.values())[0]
+        if param.annotation != Flow:
+            raise ValueError("Argument must be of type Flow")
+        if sig.return_annotation != Flow:
+            raise ValueError("Return value must be of type Flow")
+        
+        node_spec = extract_node_spec(func, name, description)
+        a_model = FlowFactory.create_flow(
+                             name = node_spec.name,
+                             display_name = display_name,
+                             description = node_spec.description,
+                             input_schema = input_schema,
+                             output_schema = output_schema,
+                             initiators = initiators)
+
+        # logger.info("Creating flow model: %s", a_model.spec.name)
+
+        # @wraps(func)
+        # def wrapper(*args, **kwargs):
+        #     result = func(a_model)
+        #     if not isinstance(result, Flow):
+        #         raise ValueError("Return value must be of type Flow")
+        #     return result
+
+        return FlowWrapper(func, a_model)
+
+    if len(args) == 1 and callable(args[0]):
+        return decorator(args[0])
+    else:
+        return decorator

ibm_watsonx_orchestrate/experimental/flow_builder/flows/events.py

@@ -0,0 +1,72 @@
+import redis
+import time
+import json
+from dotenv import load_dotenv
+import os
+
+from typing import (
+    AsyncIterator, Union
+)
+
+from ..types import (
+    FlowEventType, TaskEventType, FlowEvent, FlowContext
+)
+
+class StreamConsumer:
+    def __init__(self, instance_id: str):
+        
+        load_dotenv()
+        self.redis_host = os.getenv("REDIS_HOST", "localhost")
+        self.redis_port = os.getenv("REDIS_PORT", 6379)
+        self.redis_db = os.getenv("REDIS_DB", 0)
+        self.redis = redis.Redis(host=self.redis_host, port=self.redis_port, db=self.redis_db)
+        self.instance_id = instance_id
+        self.stream_name = f"tempus:{self.instance_id}"
+        self.last_processed_id = 0
+        
+
+    async def consume(self) -> AsyncIterator[FlowEvent]:
+        
+        while True:
+            try:
+                # XREAD command: Read new messages from the stream
+                messages = self.redis.xread({self.stream_name: self.last_processed_id}, block=5000, count=10)
+
+                for stream, events in messages:
+                    for event_id, event_data in events:
+                        self.last_processed_id = event_id  # Update the last read event ID
+                        flow_event = deserialize_flow_event(event_data)
+                        yield flow_event
+
+            except Exception as e:
+                print(f"Error occurred: {e}")
+                time.sleep(5)  # Wait for 5 seconds before retrying
+
+            time.sleep(1)  # Sleep for 1 second before checking for new messages
+
+def deserialize_flow_event(byte_data: bytes) -> FlowEvent:
+    """Deserialize byte data into a FlowEvent object."""
+    # Decode the byte data
+    decoded_data = byte_data[b'message'].decode('utf-8')
+    
+    # Parse the JSON string into a dictionary
+    parsed_data = json.loads(decoded_data)
+    
+    # Deserialize into FlowEvent using Pydantic's parsing
+    flow_event = FlowEvent(
+        kind=get_event_type(parsed_data["kind"]),
+        context=FlowContext(**parsed_data["context"]) if "context" in parsed_data and parsed_data["context"] != {} else None,
+        error=json.loads(parsed_data["error"]) if "error" in parsed_data and parsed_data["error"] != {} and len(parsed_data["error"]) > 0 else None,
+    )
+    
+    return flow_event
+
+def get_event_type(selected_event_type: str) -> Union[FlowEventType, TaskEventType]:
+    """Selects the right event type from the corresponding enumerator"""
+    eventKind = selected_event_type.upper()
+    if eventKind in FlowEventType.__members__:
+        return FlowEventType(selected_event_type)
+    elif eventKind in TaskEventType.__members__:
+        return TaskEventType(selected_event_type)
+    else:
+        raise ValueError(f"Invalid event type: {eventKind}")