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

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -147,16 +147,10 @@ class ConnectionsClient(BaseAPIClient):
         if conn_id is None:
             return ""
         try:
-            connections = self.list()
+            app_details = self._get(f"/connections/applications/id/{conn_id}")
+            return app_details.get("app_id")
         except ClientAPIException as e:
             if e.response.status_code == 404:
                 logger.warning(f"Connections not found. Returning connection ID: {conn_id}")
                 return conn_id
-            raise
-
-        app_id = next((conn.app_id for conn in connections if conn.connection_id == conn_id), None)
-
-        if app_id is None:
-            logger.warning(f"Connection with ID {conn_id} not found. Returning connection ID.")
-            return conn_id
-        return app_id
+            raise e

ibm_watsonx_orchestrate/client/model_policies/model_policies_client.py

@@ -0,0 +1,47 @@
+from typing import List
+
+from pydantic import ValidationError
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+
+import logging
+
+from ibm_watsonx_orchestrate.client.model_policies.types import ModelPolicy
+from ibm_watsonx_orchestrate.client.models.types import ListVirtualModel, CreateVirtualModel
+
+logger = logging.getLogger(__name__)
+
+
+
+
+
+class ModelPoliciesClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for ModelPolicies endpoint
+    """
+    # POST api/v1/model_policy
+    def create(self, model: ModelPolicy) -> None:
+        self._post("/model_policy", data=model.model_dump())
+
+    # DELETE api/v1/model_policy/{model_policy_id}
+    def delete(self, model_policy_id: str) -> dict:
+        return self._delete(f"/model_policy/{model_policy_id}")
+
+    # GET /api/v1/model_policy/{app_id}
+    def get(self, model_policy_id: str):
+        raise NotImplementedError
+
+
+    # GET api/v1/model_policy
+    def list(self) -> List[ModelPolicy]:
+        try:
+            res = self._get(f"/model_policy")
+            return [ModelPolicy.model_validate(policy) for policy in res]
+        except ValidationError as e:
+            logger.error("Received unexpected response from server")
+            raise e
+        except ClientAPIException as e:
+            if e.response.status_code == 404:
+                return []
+            raise e
+
+

ibm_watsonx_orchestrate/client/model_policies/types.py

@@ -0,0 +1,36 @@
+from enum import Enum
+from typing import Optional, List, Dict, Any, Union
+
+from pydantic import Field, BaseModel, ConfigDict
+
+class ModelPolicyStrategyMode(str, Enum):
+    LOAD_BALANCED = "loadbalance"
+    FALL_BACK = "fallback"
+    SINGLE = "single"
+
+class ModelPolicyStrategy(BaseModel):
+    mode: ModelPolicyStrategyMode = None
+    on_status_codes: List[int] = None
+
+class ModelPolicyRetry(BaseModel):
+    attempts: int = None
+    on_status_codes: List[int] = None
+
+class ModelPolicyTarget(BaseModel):
+    model_id: str = None
+    weight: int = None
+
+
+class ModelPolicyInner(BaseModel):
+    strategy: ModelPolicyStrategy = None
+    retry: ModelPolicyRetry = None
+    targets: List[Union[ModelPolicyTarget, 'ModelPolicyInner']] = None
+
+
+class ModelPolicy(BaseModel):
+    model_config = ConfigDict(extra='allow')
+
+    name: str
+    display_name: str
+    policy: ModelPolicyInner
+

ibm_watsonx_orchestrate/client/models/models_client.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from pydantic import ValidationError
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+
+import logging
+
+from ibm_watsonx_orchestrate.client.models.types import ListVirtualModel, CreateVirtualModel
+
+logger = logging.getLogger(__name__)
+
+
+
+
+
+class ModelsClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for Models endpoint
+    """
+    # POST api/v1/models
+    def create(self, model: CreateVirtualModel) -> None:
+        self._post("/models", data=model.model_dump())
+
+    # DELETE api/v1/models/{model_id}
+    def delete(self, model_id: str) -> dict:
+        return self._delete(f"/models/{model_id}")
+
+    # GET /api/v1/models/{app_id}
+    def get(self, model_id: str):
+        raise NotImplementedError
+
+
+    # GET api/v1/models
+    def list(self) -> List[ListVirtualModel]:
+        try:
+            res = self._get(f"/models")
+            return [ListVirtualModel.model_validate(conn) for conn in res]
+        except ValidationError as e:
+            logger.error("Received unexpected response from server")
+            raise e
+        except ClientAPIException as e:
+            if e.response.status_code == 404:
+                return []
+            raise e
+
+

ibm_watsonx_orchestrate/client/models/types.py

@@ -0,0 +1,177 @@
+from typing import Optional, List, Dict, Any, Union
+from enum import Enum
+from pydantic import Field, BaseModel, ConfigDict
+
+class  ModelProvider(str, Enum):
+    OPENAI = 'openai'
+    A21 = 'a21'
+    ANTHROPIC = 'anthropic'
+    ANYSCALE = 'anyscale'
+    AZURE_OPENAI = 'azure-openai'
+    AZURE_AI = 'azure-ai'
+    BEDROCK = 'bedrock'
+    CEREBRAS = 'cerebras'
+    COHERE = 'cohere'
+    GOOGLE = 'google'
+    VERTEX_AI = 'vertex-ai'
+    GROQ = 'groq'
+    HUGGINGFACE = 'huggingface'
+    MISTRAL_AI = 'mistral-ai'
+    JINA = 'jina'
+    OLLAMA = 'ollama'
+    OPENROUTER = 'openrouter'
+    STABILITY_AI = 'stability-ai'
+    TOGETHER_AI = 'together-ai'
+    WATSONX = 'watsonx'
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+    
+
+class ProviderConfig(BaseModel):
+    # Required fields
+    provider: Optional[str]=''
+
+
+    api_key: Optional[str] = '' # this is not optional
+    url_to_fetch: Optional[str] = Field(None, alias="urlToFetch")
+
+    # Misc
+    custom_host: Optional[str] = Field(None, alias="customHost")
+    forward_headers: Optional[List[str]] = Field(None, alias="forwardHeaders")
+    index: Optional[int] = None
+    cache: Optional[Union[str, Dict[str, Any]]] = None  # Define CacheSettings if needed
+    metadata: Optional[Dict[str, str]] = None
+    request_timeout: Optional[int] = Field(None, alias="requestTimeout")
+    transform_to_form_data: Optional[bool] = Field(None, alias="transformToFormData")
+
+    # Azure specific
+    azure_resource_name: Optional[str] = Field(None, alias="resourceName")
+    azure_deployment_id: Optional[str] = Field(None, alias="deploymentId")
+    azure_api_version: Optional[str] = Field(None, alias="apiVersion")
+    ad_auth: Optional[str] = Field(None, alias="adAuth")
+    azure_auth_mode: Optional[str] = Field(None, alias="azureAuthMode")
+    azure_managed_client_id: Optional[str] = Field(None, alias="azureManagedClientId")
+    azure_entra_client_id: Optional[str] = Field(None, alias="azureEntraClientId")
+    azure_entra_client_secret: Optional[str] = Field(None, alias="azureEntraClientSecret")
+    azure_entra_tenant_id: Optional[str] = Field(None, alias="azureEntraTenantId")
+    azure_ad_token: Optional[str] = Field(None, alias="azureAdToken")
+    azure_model_name: Optional[str] = Field(None, alias="azureModelName")
+
+    # Workers AI specific
+    workers_ai_account_id: Optional[str] = Field(None, alias="workersAiAccountId")
+
+
+    # AWS
+    aws_secret_access_key: Optional[str] = Field(None, alias="awsSecretAccessKey")
+    aws_access_key_id: Optional[str] = Field(None, alias="awsAccessKeyId")
+    aws_session_token: Optional[str] = Field(None, alias="awsSessionToken")
+    aws_region: Optional[str] = Field(None, alias="awsRegion")
+    aws_auth_type: Optional[str] = Field(None, alias="awsAuthType")
+    aws_role_arn: Optional[str] = Field(None, alias="awsRoleArn")
+    aws_external_id: Optional[str] = Field(None, alias="awsExternalId")
+    aws_s3_bucket: Optional[str] = Field(None, alias="awsS3Bucket")
+    aws_s3_object_key: Optional[str] = Field(None, alias="awsS3ObjectKey")
+    aws_bedrock_model: Optional[str] = Field(None, alias="awsBedrockModel")
+    aws_server_side_encryption: Optional[str] = Field(None, alias="awsServerSideEncryption")
+    aws_server_side_encryption_kms_key_id: Optional[str] = Field(None, alias="awsServerSideEncryptionKMSKeyId")
+
+    # Sagemaker
+    amzn_sagemaker_custom_attributes: Optional[str] = Field(None, alias="amznSagemakerCustomAttributes")
+    amzn_sagemaker_target_model: Optional[str] = Field(None, alias="amznSagemakerTargetModel")
+    amzn_sagemaker_target_variant: Optional[str] = Field(None, alias="amznSagemakerTargetVariant")
+    amzn_sagemaker_target_container_hostname: Optional[str] = Field(None, alias="amznSagemakerTargetContainerHostname")
+    amzn_sagemaker_inference_id: Optional[str] = Field(None, alias="amznSagemakerInferenceId")
+    amzn_sagemaker_enable_explanations: Optional[str] = Field(None, alias="amznSagemakerEnableExplanations")
+    amzn_sagemaker_inference_component: Optional[str] = Field(None, alias="amznSagemakerInferenceComponent")
+    amzn_sagemaker_session_id: Optional[str] = Field(None, alias="amznSagemakerSessionId")
+    amzn_sagemaker_model_name: Optional[str] = Field(None, alias="amznSagemakerModelName")
+
+    # Stability AI
+    stability_client_id: Optional[str] = Field(None, alias="stabilityClientId")
+    stability_client_user_id: Optional[str] = Field(None, alias="stabilityClientUserId")
+    stability_client_version: Optional[str] = Field(None, alias="stabilityClientVersion")
+
+    # Hugging Face
+    huggingface_base_url: Optional[str] = Field(None, alias="huggingfaceBaseUrl")
+
+    # Google Vertex AI
+    vertex_region: Optional[str] = Field(None, alias="vertexRegion")
+    vertex_project_id: Optional[str] = Field(None, alias="vertexProjectId")
+    vertex_service_account_json: Optional[Dict[str, Any]] = Field(None, alias="vertexServiceAccountJson")
+    vertex_storage_bucket_name: Optional[str] = Field(None, alias="vertexStorageBucketName")
+    vertex_model_name: Optional[str] = Field(None, alias="vertexModelName")
+
+    filename: Optional[str] = None
+
+    after_request_hooks: Optional[List[Dict[str, Any]]] = Field(None, alias="afterRequestHooks")
+    before_request_hooks: Optional[List[Dict[str, Any]]] = Field(None, alias="beforeRequestHooks")
+    default_input_guardrails: Optional[List[Dict[str, Any]]] = Field(None, alias="defaultInputGuardrails")
+    default_output_guardrails: Optional[List[Dict[str, Any]]] = Field(None, alias="defaultOutputGuardrails")
+
+    # OpenAI
+    openai_project: Optional[str] = Field(None, alias="openaiProject")
+    openai_organization: Optional[str] = Field(None, alias="openaiOrganization")
+    openai_beta: Optional[str] = Field(None, alias="openaiBeta")
+
+    # Azure Inference
+    azure_deployment_name: Optional[str] = Field(None, alias="azureDeploymentName")
+    azure_api_version: Optional[str] = Field(None, alias="azureApiVersion")
+    azure_extra_params: Optional[str] = Field(None, alias="azureExtraParams")
+    azure_foundry_url: Optional[str] = Field(None, alias="azureFoundryUrl")
+
+    strict_open_ai_compliance: Optional[bool] = Field(False, alias="strictOpenAiCompliance")
+    mistral_fim_completion: Optional[str] = Field(None, alias="mistralFimCompletion")
+
+    # Anthropic
+    anthropic_beta: Optional[str] = Field(None, alias="anthropicBeta")
+    anthropic_version: Optional[str] = Field(None, alias="anthropicVersion")
+
+    # Fireworks
+    fireworks_account_id: Optional[str] = Field(None, alias="fireworksAccountId")
+
+    # Cortex
+    snowflake_account: Optional[str] = Field(None, alias="snowflakeAccount")
+
+    # WatsonX
+    watsonx_version: Optional[str] = Field(None, alias="watsonxVersion")
+    watsonx_space_id: Optional[str] = Field(None, alias="watsonxSpaceId")
+    watsonx_project_id: Optional[str] = Field(None, alias="watsonxProjectId")
+
+    model_config = {
+        "populate_by_name": True,  # Replaces allow_population_by_field_name
+        "extra": "forbid",         # Same as before
+        "json_schema_extra": lambda schema: schema.get("properties", {}).pop("provider", None)
+    }
+
+
+
+class CreateVirtualModel(BaseModel):
+    model_config = ConfigDict(extra='allow')
+
+    name: str
+    display_name: Optional[str]
+    description: Optional[str]
+    config: Optional[dict] = None
+    provider_config: ProviderConfig
+    tags: List[str]
+    model_type: str = 'chat'
+
+
+class ListVirtualModel(BaseModel):
+    model_config = ConfigDict(extra='allow')
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    display_name: Optional[str] = None
+    description: Optional[str] = None
+    provider: Optional[str] = None
+    # model_configuration: Optional[dict] = None
+    provider_config: Optional[ProviderConfig] = None
+    tags: Optional[List[str]] = None
+    model_type: Optional[str] = None
+
+ANTHROPIC_DEFAULT_MAX_TOKENS = 4096

ibm_watsonx_orchestrate/client/toolkit/toolkit_client.py

@@ -1,9 +1,18 @@
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from ibm_watsonx_orchestrate.client.utils import is_local_dev
 from typing_extensions import List
 import os
 import json
 
 class ToolKitClient(BaseAPIClient):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.base_endpoint = "/orchestrate/toolkits" if is_local_dev(self.base_url) else "/toolkits"
+
+    def get(self) -> dict:
+        return self._get(self.base_endpoint)
+
     # POST /toolkits/prepare/list-tools
     def list_tools(self, zip_file_path: str, command: str, args: List[str]) -> List[str]:
         """
@@ -24,7 +33,7 @@ class ToolKitClient(BaseAPIClient):
                 "file": (filename, f, "application/zip"),
             }
 
-            response = self._post("/orchestrate/toolkits/prepare/list-tools", files=files)
+            response = self._post(f"{self.base_endpoint}/prepare/list-tools", files=files)
 
         return response.get("tools", [])
 
@@ -35,7 +44,7 @@ class ToolKitClient(BaseAPIClient):
         Creates new toolkit metadata
         """
         try:
-            return self._post("/orchestrate/toolkits", data=payload)
+            return self._post(self.base_endpoint, data=payload)
         except ClientAPIException as e:
             if e.response.status_code == 400 and "already exists" in e.response.text:
                 raise ClientAPIException(
@@ -54,25 +63,25 @@ class ToolKitClient(BaseAPIClient):
             files = {
                 "file": (filename, f, "application/zip", {"Expires": "0"})
             }
-            return self._post(f"/orchestrate/toolkits/{toolkit_id}/upload", files=files)
+            return self._post(f"{self.base_endpoint}/{toolkit_id}/upload", files=files)
         
     # DELETE /toolkits/{toolkit-id} 
     def delete(self, toolkit_id: str) -> dict:
-        return self._delete(f"/orchestrate/toolkits/{toolkit_id}")
+        return self._delete(f"{self.base_endpoint}/{toolkit_id}")
 
     def get_draft_by_name(self, toolkit_name: str) -> List[dict]:
         return self.get_drafts_by_names([toolkit_name])
 
     def get_drafts_by_names(self, toolkit_names: List[str]) -> List[dict]:
         formatted_toolkit_names = [f"names={x}" for x in toolkit_names]
-        return self._get(f"/orchestrate/toolkits?{'&'.join(formatted_toolkit_names)}")
+        return self._get(f"{self.base_endpoint}?{'&'.join(formatted_toolkit_names)}")
     
     def get_draft_by_id(self, toolkit_id: str) -> dict:
         if toolkit_id is None:
             return ""
         else:
             try:
-                toolkit = self._get(f"/orchestrate/toolkits/{toolkit_id}")
+                toolkit = self._get(f"{self.base_endpoint}/{toolkit_id}")
                 return toolkit
             except ClientAPIException as e:
                 if e.response.status_code == 404 and "not found with the given name" in e.response.text:

ibm_watsonx_orchestrate/client/tools/tempus_client.py

@@ -0,0 +1,40 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+from urllib.parse import urlparse, urlunparse
+from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
+
+DEFAULT_TEMPUS_PORT= 9044
+
+class TempusClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for Tempus endpoint
+
+    This may be temporary and may want to create a proxy API in wxo-server 
+    to redirect to the internal tempus runtime, and add a new operation in the ToolClient instead
+    """
+    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, authenticator: MCSPAuthenticator = None):
+        parsed_url = urlparse(base_url)
+       
+        # Reconstruct netloc with new port - use default above - eventually we need to open up a way through the wxo-server API
+        new_netloc = f"{parsed_url.hostname}:{DEFAULT_TEMPUS_PORT}"
+
+        # Replace netloc and rebuild the URL
+        new_url = urlunparse(parsed_url._replace(netloc=new_netloc))
+        # remove trailing slash
+
+        super().__init__(
+            base_url=new_url,
+            api_key=api_key,
+            is_local=is_local,
+            authenticator=authenticator
+        )
+        
+    def create_update_flow_model(self, flow_id: str, model: dict) -> dict:
+        return self._post(f"/v1/flow-models/{flow_id}", data=model)
+    
+    def run_flow(self, flow_id: str, input: dict) -> dict:
+        return self._post(f"/v1/flows/{flow_id}/versions/TIP/run", data=input)
+    
+    def arun_flow(self, flow_id: str, input: dict) -> dict:
+        return self._post(f"/v1/flows/{flow_id}/versions/TIP/run/async", data=input)
+

ibm_watsonx_orchestrate/client/tools/tool_client.py

@@ -21,6 +21,10 @@ class ToolClient(BaseAPIClient):
     def upload_tools_artifact(self, tool_id: str, file_path: str) -> dict:
         return self._post(f"/tools/{tool_id}/upload", files={"file": (f"{tool_id}.zip", open(file_path, "rb"), "application/zip", {"Expires": "0"})})
     
+    def download_tools_artifact(self, tool_id: str) -> bytes:
+        response = self._get(f"/tools/{tool_id}/download", return_raw=True)
+        return response.content
+
     def get_draft_by_name(self, tool_name: str) -> List[dict]:
         return self.get_drafts_by_names([tool_name])
 
@@ -39,3 +43,7 @@ class ToolClient(BaseAPIClient):
                 if e.response.status_code == 404 and "not found with the given name" in e.response.text:
                     return ""
                 raise(e)
+    
+    def get_drafts_by_ids(self, tool_ids: List[str]) -> List[dict]:
+        formatted_tool_ids = [f"ids={x}" for x in tool_ids]
+        return self._get(f"/tools?{'&'.join(formatted_tool_ids)}")

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -49,6 +49,17 @@ services:
     ports:
       - 3001:3001
 
+  ai-gateway:
+    image: ${AI_GATEWAY_REGISTRY:-us.icr.io/watson-orchestrate-private}/ai-gateway:${AI_GATEWAY_TAG:-latest}
+    platform: linux/amd64
+    restart: unless-stopped
+    ports:
+      - "8787:8787"
+    environment:  
+      WATSONX_API_KEY: ${WATSONX_APIKEY}
+      WATSONX_URL: ${WATSONX_URL}
+      WATSONX_SPACE_ID: ${WATSONX_SPACE_ID}
+
   ui:
     image: ${UI_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-chat:${UITAG:-latest}
     platform: linux/amd64
@@ -95,6 +106,7 @@ services:
     environment:
       WXO_DEPLOYMENT_TYPE: 'laptop'
       AGENT_RUNTIME_ENDPOINT: http://wxo-server:4321
+      TEMPUS_RUNTIME_ENDPOINT: http://wxo-tempus-runtime:9044
     command: 'npm start'
     ports:
       - '4025:4025'
@@ -210,14 +222,21 @@ services:
     volumes:
       - ./sdk:/packages
       - tools:/tools
+    
     command: >
-        bash -c "mkdir -p /tmp/certs && 
-                  openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /tmp/certs/key.pem -out /tmp/certs/cert.pem -subj '/CN=localhost' && 
-                  uvicorn --host 0.0.0.0 --port 4322 --ssl-keyfile /tmp/certs/key.pem --ssl-certfile /tmp/certs/cert.pem --log-config /app/config/logs/log_conf.yaml --workers 2 --log-level debug wo_archer.api.main:app & 
-                  (for i in {1..20}; do curl --silent --fail -k https://127.0.0.1:4322/health/alive && echo '[INFO] HTTPS Service ready' && break || echo '[INFO] Waiting for HTTPS service...' && sleep 30; done; curl --silent --fail -k https://127.0.0.1:4322/health/alive || (echo '[ERROR] HTTPS service failed to start' && exit 1) ) &&
-                  uvicorn --host 0.0.0.0 --port 4321 --log-config /app/config/logs/log_conf.yaml --log-level debug --workers 5 wo_archer.api.main:app & 
-                  (for i in {1..20}; do curl --silent --fail -k http://127.0.0.1:4321/health/alive && echo '[INFO] HTTP Service ready' && break || echo '[INFO] Waiting for HTTP service...' && sleep 30; done; curl --silent --fail -k http://127.0.0.1:4321/health/alive || (echo '[ERROR] HTTP service failed to start' && exit 1) ) && 
-                  wait"
+       bash -c '
+          export PYTHONPATH="/tmp/monkey:$PYTHONPATH"
+          mkdir -p /tmp/monkey &&
+
+          echo -e "from uvicorn.supervisors.multiprocess import Process\n_original_is_alive = Process.is_alive\ndef patched_is_alive(self, timeout: float = 30):\n    return _original_is_alive(self, timeout=30)\nProcess.is_alive = patched_is_alive" > /tmp/monkey/sitecustomize.py &&
+
+          uvicorn --host 0.0.0.0 --port 4321 --log-config /app/config/logs/log_conf.yaml --log-level debug --workers 5 wo_archer.api.main:app &
+
+          for i in {1..40}; do curl --silent --fail http://127.0.0.1:4321/health/alive && echo "[INFO] HTTP Service ready" && break || echo "[INFO] Waiting for HTTP service..." && sleep 10; done;
+          curl --silent --fail http://127.0.0.1:4321/health/alive || (echo "[ERROR] HTTP service failed to start" && exit 1);
+
+          wait
+        '
     depends_on:
       wxo-server-redis:
           condition: service_started
@@ -294,6 +313,15 @@ services:
       MILVUS_DB_NAME: default
       MILVUS_USERNAME: root
       MILVUS_PASSWORD: Milvus
+      WO_API_KEY: ${WO_API_KEY}
+      WO_USERNAME: ${WO_USERNAME}
+      WO_PASSWORD: ${WO_PASSWORD}
+      WO_INSTANCE: ${WO_INSTANCE}
+      USE_SAAS_ML_TOOLS_RUNTIME: ${USE_SAAS_ML_TOOLS_RUNTIME}
+      AUTHORIZATION_URL: ${AUTHORIZATION_URL}
+      WO_AUTH_TYPE: ${WO_AUTH_TYPE}
+      AI_GATEWAY_BASE_URL: ${AI_GATEWAY_BASE_URL}
+      AI_GATEWAY_ENABLED : ${AI_GATEWAY_ENABLED}
 
   wxo-server-worker:
     image: ${WORKER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-conversation_controller:${WORKER_TAG:-latest}
@@ -311,6 +339,8 @@ services:
       - ./sdk:/packages
       - tools:/tools
     environment:
+      AI_GATEWAY_ENABLED : ${AI_GATEWAY_ENABLED}
+      AI_GATEWAY_BASE_URL: ${AI_GATEWAY_BASE_URL}
       IS_WXO_LITE: 'TRUE'
       TRM_BASE_URL: http://tools-runtime-manager:8080
       AGENT_STEP_DETAILS: redis://wxo-server-redis:6379/0
@@ -372,6 +402,13 @@ services:
       MILVUS_DB_NAME: default
       MILVUS_USERNAME: root
       MILVUS_PASSWORD: Milvus
+      WO_API_KEY: ${WO_API_KEY}
+      WO_USERNAME: ${WO_USERNAME}
+      WO_PASSWORD: ${WO_PASSWORD}
+      WO_INSTANCE: ${WO_INSTANCE}
+      USE_SAAS_ML_TOOLS_RUNTIME: ${USE_SAAS_ML_TOOLS_RUNTIME}
+      AUTHORIZATION_URL: ${AUTHORIZATION_URL}
+      WO_AUTH_TYPE: ${WO_AUTH_TYPE}
   
   tools-runtime-manager:
     image: ${TRM_REGISTRY:-us.icr.io/watson-orchestrate-private}/tools-runtime-manager:${TRM_TAG:-latest}
@@ -407,6 +444,12 @@ services:
       VOLUME_MOUNT_PATH: "/shared-data"
       TOOLS_RUNTIME_MANAGER_BASE_URL: ${TOOLS_RUNTIME_MANAGER_BASE_URL}
       CONNECTION_SERVICE_BASE_URL: http://wxo-server-connection-manager:3001
+      STORAGE_S3_BUCKET: ${STORAGE_S3_BUCKET:-wxo-server-storage-bucket}  
+      STORAGE_S3_ENDPOINT: http://wxo-server-minio:9000
+      STORAGE_S3_FORCE_PATH_STYLE: 'true'
+      STORAGE_S3_REGION: us-east-1
+      AWS_ACCESS_KEY_ID: ${MINIO_ROOT_USER:-minioadmin}
+      AWS_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:-watsonxorchestrate}
     extra_hosts:
       - "host.docker.internal:host-gateway"
 
@@ -432,6 +475,12 @@ services:
       DB_PASSWORD: ${DB_PASSWORD:-postgres}
       DB_NAME: ${DB_NAME:-postgres}
       DB_SSLMODE: ${DB_SSLMODE:-disable}  # Disable SSL if not configured
+      STORAGE_S3_BUCKET: ${STORAGE_S3_BUCKET:-wxo-server-storage-bucket}  
+      STORAGE_S3_ENDPOINT: http://wxo-server-minio:9000
+      STORAGE_S3_FORCE_PATH_STYLE: 'true'
+      STORAGE_S3_REGION: us-east-1
+      AWS_ACCESS_KEY_ID: ${MINIO_ROOT_USER:-minioadmin}
+      AWS_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:-watsonxorchestrate}
 
 ########################
 # LANGFUSE dependencies
@@ -531,11 +580,8 @@ services:
   wxo-tempus-runtime:
     image: ${FLOW_RUMTIME_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-tempus-runtime:${FLOW_RUNTIME_TAG:-latest}
     restart: unless-stopped
-    platform: linux/amd64
-    profiles: [with-tempus-runtime]
     environment:
       NODE_TLS_REJECT_UNAUTHORIZED: "0"
-      COMMON_CONFIG_FILE: "/shared/common-config.yaml"
       SERVER_MODE: production
       SERVER_ENVIRONMENT: SDK
       SERVER_HTTP_PORT: "9044"
@@ -557,6 +603,17 @@ services:
       PG_DATABASE: ${POSTGRES_USER:-postgres}
       USER_MGMT_BASE_URL: "" # TODO
       WXO_SERVER_BASE_URL: http://wxo-server:4321
+      TRM_SERVER_BASE_URL: http://tools-runtime-manager:8080
+      CONNECTION_MANAGER_SERVER_BASE_URL: http://wxo-server-connection-manager:3001
+      REDIS_ENDPOINT: wxo-server-redis:6379
+      REDIS_USER:
+      REDIS_PASSWORD:
+      REDIS_TLS: false
+      LANGFUSE_ENABLED: ${LANGFUSE_ENABLED:-false}
+      LANGFUSE_HOST: ${LANGFUSE_HOST:-http://langfuse-web:3000}
+      LANGFUSE_PUBLIC_KEY:  ${LANGFUSE_PUBLIC_KEY:-pk-lf-7417757e-d6df-421b-957e-683b76acb5df}
+      LANGFUSE_SECRET_KEY:  ${LANGFUSE_PRIVATE_KEY:-sk-lf-7bc4da63-7b2b-40c0-b5eb-1e0cf64f9af2}
+      LOG_LEVEL: info
     healthcheck:
       test: curl -k http://localhost:9044/readiness --fail
       interval: 5s
@@ -564,8 +621,6 @@ services:
       retries: 5
     ports:
       - 9044:9044
-    volumes:
-      - ./tempus/common-config.yaml:/shared/common-config.yaml
     depends_on:
       - wxo-server-db
     
@@ -595,4 +650,4 @@ volumes:
 networks:
   default:
     name: wxo-server
-    
+