ibm-watsonx-orchestrate 1.9.0b1__py3-none-any.whl → 1.10.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/client/agents/agent_client.py

@@ -1,7 +1,26 @@
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
 from typing_extensions import List, Optional
+from enum import Enum
+
 from ibm_watsonx_orchestrate.client.utils import is_local_dev
 from pydantic import BaseModel
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+POLL_INTERVAL = 2
+MAX_RETRIES = 10
+
+class ReleaseMode(str, Enum):
+    DEPLOY = "deploy"
+    UNDEPLOY = "undeploy"
+
+class ReleaseStatus(str, Enum):
+    SUCCESS = "success"
+    NONE = "none"
+    FAILED = "failed"
+    IN_PROGRESS = "in_progress"
 
 def transform_agents_from_flat_agent_spec(agents: dict | list[dict] ) -> dict | list[dict]:
     if isinstance(agents,list):
@@ -83,7 +102,6 @@ class AgentClient(BaseAPIClient):
         super().__init__(*args, **kwargs)
         self.base_endpoint = "/orchestrate/agents" if is_local_dev(self.base_url) else "/agents"
 
-
     def create(self, payload: dict) -> AgentUpsertResponse:
         response = self._post(self.base_endpoint, data=transform_agents_from_flat_agent_spec(payload))
         return AgentUpsertResponse.model_validate(response)
@@ -120,4 +138,49 @@ class AgentClient(BaseAPIClient):
     def get_drafts_by_ids(self, agent_ids: List[str]) -> List[dict]:
         formatted_agent_ids = [f"ids={x}" for x  in agent_ids]
         return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_ids)}&include_hidden=true"))
+
+    def poll_release_status(self, agent_id: str, environment_id: str, mode: str = "deploy") -> bool:
+        expected_status = {
+            ReleaseMode.DEPLOY: ReleaseStatus.SUCCESS,
+            ReleaseMode.UNDEPLOY: ReleaseStatus.NONE
+        }[mode]
+
+        for attempt in range(MAX_RETRIES):
+            try:
+                response = self._get(
+                    f"{self.base_endpoint}/{agent_id}/releases/status?environment_id={environment_id}"
+                )
+            except Exception as e:
+                logger.error(f"Polling for Deployment/Undeployment failed on attempt {attempt + 1}: {e}")
+                return False
+
+            if not isinstance(response, dict):
+                logger.warning(f"Invalid response format: {response}")
+                return False
+            
+            status = response.get("deployment_status")
+
+            if status == expected_status:
+                return True
+            elif status == "failed":
+                return False
+            elif status == "in_progress":
+                pass
+
+            time.sleep(POLL_INTERVAL)
+
+        logger.warning(f"{mode.capitalize()} status polling timed out")
+        return False
+
+    def deploy(self, agent_id: str, environment_id: str) -> bool:
+        self._post(f"{self.base_endpoint}/{agent_id}/releases", data={"environment_id": environment_id})
+        return self.poll_release_status(agent_id, environment_id, mode=ReleaseMode.DEPLOY)
+
+    def undeploy(self, agent_id: str, version: str, environment_id: str) -> bool:
+        self._post(f"{self.base_endpoint}/{agent_id}/releases/{version}/undeploy")
+        return self.poll_release_status(agent_id, environment_id, mode=ReleaseMode.UNDEPLOY)
+    
+    def get_environments_for_agent(self, agent_id: str):
+        return self._get(f"{self.base_endpoint}/{agent_id}/environment")
+
     

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -3,6 +3,7 @@ from typing import List
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
 from pydantic import BaseModel, ValidationError
 from typing import Optional
+from enum import Enum
 
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
 from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType
@@ -12,12 +13,23 @@ import logging
 logger = logging.getLogger(__name__)
 
 
+class FetchConfigAuthTypes(str, Enum):
+    BASIC_AUTH = ConnectionType.BASIC_AUTH.value
+    BEARER_TOKEN = ConnectionType.BEARER_TOKEN.value
+    API_KEY_AUTH = ConnectionType.API_KEY_AUTH.value
+    OAUTH2_AUTH_CODE = ConnectionType.OAUTH2_AUTH_CODE.value
+    OAUTH2_IMPLICIT = 'oauth2_implicit'
+    OAUTH2_PASSWORD = 'oauth2_password'
+    OAUTH2_CLIENT_CREDS = ConnectionType.OAUTH2_CLIENT_CREDS.value
+    OAUTH_ON_BEHALF_OF_FLOW = ConnectionType.OAUTH_ON_BEHALF_OF_FLOW.value
+    KEY_VALUE = ConnectionType.KEY_VALUE.value
+
 class ListConfigsResponse(BaseModel):
     connection_id: str = None,
     app_id: str = None
     name: str = None
     security_scheme: ConnectionSecurityScheme | None = None,
-    auth_type: ConnectionAuthType | None = None,
+    auth_type: FetchConfigAuthTypes | None = None,
     environment:  ConnectionEnvironment | None = None,
     preference: ConnectionPreference | None = None,
     credentials_entered: bool | None = False
@@ -28,7 +40,7 @@ class GetConfigResponse(BaseModel):
     app_id: str = None
     environment: ConnectionEnvironment = None
     preference: ConnectionPreference = None
-    auth_type: ConnectionAuthType | None = None
+    auth_type: FetchConfigAuthTypes | None = None
     sso: bool = None
     security_scheme: ConnectionSecurityScheme = None
     server_url: str | None = None

ibm_watsonx_orchestrate/client/copilot/cpe/copilot_cpe_client.py

@@ -21,13 +21,15 @@ class CPEClient(BaseAPIClient):
         }
 
 
-    def submit_pre_cpe_chat(self, user_message: str | None =None, tools: Dict[str, Any] = None, agents: Dict[str, Any] = None) -> dict:
+    def submit_pre_cpe_chat(self, user_message: str | None =None, tools: Dict[str, Any] = None, collaborators: Dict[str, Any] = None, knowledge_bases: Dict[str, Any] = None, selected:bool=False) -> dict:
         payload = {
             "message": user_message,
             "tools": tools,
-            "agents": agents,
+            "collaborators": collaborators,
+            "knowledge_bases": knowledge_bases,
             "chat_id": self.chat_id,
-            "chat_model_name": self.chat_model_name
+            "chat_model_name": self.chat_model_name,
+            'selected':selected
         }
 
         response = self._post_nd_json("/wxo-cpe/create-agent", data=payload)

ibm_watsonx_orchestrate/client/voice_configurations/voice_configurations_client.py

@@ -0,0 +1,75 @@
+from pydantic import ValidationError
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from ibm_watsonx_orchestrate.client.client_errors import MissingArgument
+
+import logging
+logger = logging.getLogger(__name__)
+
+class VoiceConfigurationsClient(BaseAPIClient):
+
+  def create(self, voice_config: VoiceConfiguration) -> dict:
+    return self._post("/voice_configurations", data=voice_config.model_dump(exclude_none=True))
+
+
+  def update(self, voice_config_id: str, voice_config: VoiceConfiguration) -> dict:    
+    if voice_config_id in [None,""]:
+      raise MissingArgument("voice_config_id")
+    return self._patch(f"/voice_configurations/{voice_config_id}", data=voice_config.model_dump(exclude_none=True))
+
+
+  def get_by_id(self, voice_config_id: str) -> dict | None:
+    if voice_config_id in [None,""]:
+      raise MissingArgument("voice_config_id")
+    
+    try:
+      response = self._get(f"/voice_configurations/{voice_config_id}")
+      return VoiceConfiguration.model_validate(response)
+    
+    except ClientAPIException as e:
+      if e.response.status_code == 404:
+        return None
+      raise e
+    
+    except ValidationError as e:
+      logger.error("Recieved unexpected response from server")
+      raise e
+    
+  def get_by_name(self, name: str) -> list[VoiceConfiguration]:
+    return self.get_by_names([name])
+
+  def get_by_names(self, names: list[str]) -> list[VoiceConfiguration]:
+    # server will implement query by name, below can be uncommented then
+    # formatted_config_names = [f"names={n}" for n in names]
+    # return self._get(f"/voice_configurations?{"&".join(formatted_config_names)}")
+    config_list = self.list()
+    filtered_list = [cfg for cfg in config_list if cfg.name in names]
+
+    try:
+      return [ VoiceConfiguration.model_validate(cfg) for cfg in filtered_list ]
+    except ValidationError as e:
+      logger.error("Recieved unexpected response from server")
+      raise e
+
+
+
+
+  def delete(self, voice_config_id: str) -> None:
+    if voice_config_id in [None,""]:
+      raise MissingArgument("voice_config_id")
+    self._delete(f"/voice_configurations/{voice_config_id}")
+
+
+  def list(self) -> list[dict]:
+    try:
+      response = self._get("/voice_configurations")
+      return [VoiceConfiguration.model_validate(x) for x in response.get('voice_configurations',[])]
+    
+    except ClientAPIException as e:
+      if e.response.status_code == 404:
+        return []
+      raise e
+    
+    except ValidationError as e:
+      logger.error("Recieved unexpected response from server")
+      raise e

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -102,6 +102,7 @@ services:
       DISMISS_NOTIFICATION_TIMEOUT: 10000
       STANDALONE: "true"
       STREAM_TIMEOUT: ${STREAM_TIMEOUT:-120000}
+      WXO_VOICE_URL: http://localhost:9876/v1
     command: "./StartServer.sh"
     ports:
       - "3000:4002"
@@ -122,6 +123,11 @@ services:
       CONNECTIONS_MANAGER_ENDPOINT: http://wxo-server-connection-manager:3001
       AGENT_OPS_API_KEY: ${AGENTOPS_API_KEY}
       AGENTS_OPS_RUNTIME_ENDPOINT: https://frontend-server:443
+      DPI_WO_WDU_SERVER_ENDPOINT: https://wxo-doc-processing-service:8080
+      DPI_RAG_SERVER_ENDPOINT: https://wxo-doc-processing-llm-service:8083
+      IBM_DPS_CACHE_SERVICE: https://wxo-doc-processing-cache:8080
+      DOCPROC_BASE_URL: http://wxo-doc-processing-infra-standalone:9080
+      BUILDER_ASYNC_CALLBACK_ENDPOINT: http://wxo-builder:4025
       IS_OBSERVABILITY_FEATURE_ENABLED: "true"
       ALLOW_INSECURE_TLS: "true"
     command: 'npm start'
@@ -165,7 +171,7 @@ services:
       "
 
   wxo-milvus-standalone:
-    image: ${OPENSOURCE_REGISTRY_PROXY:-docker.io}/milvusdb/milvus:v2.5.6
+    image: ${OPENSOURCE_REGISTRY_PROXY:-docker.io}/milvusdb/milvus:v2.5.15
     command: ["milvus", "run", "standalone"]
     security_opt:
       - seccomp:unconfined
@@ -337,6 +343,7 @@ services:
       AGENTOPS_API_KEY_AUTH_ENABLED: ${AGENTOPS_API_KEY_AUTH_ENABLED:-false}
       AGENTOPS_API_KEY: ${AGENTOPS_API_KEY}
       ES_HOST: http://elasticsearch:9200
+      ORIGIN_HEADER: "internal"
 
   wxo-server-worker:
     image: ${WORKER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-conversation_controller:${WORKER_TAG:-latest}
@@ -512,7 +519,7 @@ services:
   # IBM AGENT-OPS
   ########################
   elasticsearch:
-    image: docker.elastic.co/elasticsearch/elasticsearch:8.17.5
+    image: docker.elastic.co/elasticsearch/elasticsearch:8.19.0
     profiles: [ibm-telemetry]
     environment:
       - discovery.type=single-node
@@ -549,6 +556,7 @@ services:
       - TENANT_DEFAULT_PASSWORD=${ES_PASSWORD}
       - TENANT_DEFAULT_HOSTNAME=http://elasticsearch:9200
       - DEFAULT_TENANT_ID=${DEFAULT_TENANT_ID}
+      - FORCE_SINGLE_TENANT=${FORCE_SINGLE_TENANT:-true}
     ports:
       - "9202:9201" # Expose proxy on host port 9202
     networks:
@@ -644,6 +652,7 @@ services:
       - INBOUND_API_KEY=${AGENTOPS_API_KEY}
       - DEFAULT_TENANT_ID=${DEFAULT_TENANT_ID}
       - TENANT_DEFAULT_HOSTNAME=http://elasticsearch:9200
+      - FORCE_SINGLE_TENANT=${FORCE_SINGLE_TENANT:-true}
     ports:
       - "8765:443"
     networks:
@@ -787,6 +796,7 @@ services:
       WO_INSTANCE: ${WO_INSTANCE}
       AUTHORIZATION_URL: ${AUTHORIZATION_URL}
       WO_AUTH_TYPE: ${WO_AUTH_TYPE}
+      FLOW_CALLBACK_REQUEST_RETRIES: "1"
     healthcheck:
       test: curl -k http://localhost:9044/readiness --fail
       interval: 30s
@@ -1085,6 +1095,17 @@ services:
       exit 0;
       "
 
+  wxo-server-voice:
+      image: ${VOICE_CONTROLLER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-voice:${VOICE_CONTROLLER_TAG:-latest}
+      profiles: [voice]
+      restart: unless-stopped
+      ports: 
+        - 9876:8765
+      environment:
+        WXO_BASE_DOMAIN_URL: "http://wxo-server:4321"
+        AI_GATEWAY_URL: "http://ai-gateway:8787"
+        WXO_ORIGIN_HEADER: "internal"
+
 volumes:
   tools:
     driver: local

ibm_watsonx_orchestrate/docker/default.env

@@ -57,13 +57,13 @@ EVENT_BROKER_TTL="3600"
 REGISTRY_URL=
 
 
-SERVER_TAG=31-07-2025
+SERVER_TAG=13-08-2025-b01e43e00a7c900f92057d63520be08f965b6b24
 SERVER_REGISTRY=
 
-WORKER_TAG=31-07-2025
+WORKER_TAG=13-08-2025-b01e43e00a7c900f92057d63520be08f965b6b24
 WORKER_REGISTRY=
 
-AI_GATEWAY_TAG=21-07-2025
+AI_GATEWAY_TAG=01-08-2025-v1
 AI_GATEWAY_REGISTRY=
 
 AGENT_GATEWAY_TAG=29-07-2025
@@ -77,36 +77,39 @@ AMDDBTAG=29-07-2025-9f3661b
 ARM64DBTAG=29-07-2025-9f3661b
 
 UI_REGISTRY=
-UITAG=23-07-2025
+UITAG=31-07-2025
 
 CM_REGISTRY=
 CM_TAG=24-07-2025
 
-TRM_TAG=23-07-2025-3c60549f0bac275de3e5736265a3fd49cdd3a203
+TRM_TAG=12-08-2025-5f816b3d5981afdd65fa55401d70e5aa5f734fc4
 TRM_REGISTRY=
 
-TR_TAG=23-07-2025-3c60549f0bac275de3e5736265a3fd49cdd3a203
+TR_TAG=14-08-2025-7b2f9c9
 TR_REGISTRY=
 
-BUILDER_TAG=29-07-2025
+BUILDER_TAG=12-08-2025-8f00997
 BUILDER_REGISTRY=
 
-FLOW_RUNTIME_TAG=28-07-2025-v2
+FLOW_RUNTIME_TAG=11-08-2025
 FLOW_RUMTIME_REGISTRY=
 
 
-AGENT_ANALYTICS_TAG=02-07-2025-v1
+AGENT_ANALYTICS_TAG=05-08-2025
 AGENT_ANALYTICS_REGISTRY=
 
-JAEGER_PROXY_TAG=01-07-2025
+JAEGER_PROXY_TAG=23-07-2025
 JAEGER_PROXY_REGISTRY=
 
 SOCKET_HANDLER_TAG=29-05-2025
 SOCKET_HANDLER_REGISTRY=
 
-CPE_TAG=17-07-2025
+CPE_TAG=06-08-2025-b0a20ad
 CPE_REGISTRY=
 
+VOICE_CONTROLLER_TAG=12-08-2025
+VOICE_CONTROLLER_REGISTRY=
+
 # IBM Document Processing
 WDU_TAG=2.5.0
 WDU_REGISTRY=
@@ -114,7 +117,7 @@ WDU_REGISTRY=
 DOCPROC_DPS_TAG=20250721-164412-250-503756a
 DOCPROC_LLMSERVICE_TAG=20250725-100249-111-51d3e51
 DOCPROC_CACHE_TAG=20250723-100852-70-9edc1ab
-DOCPROC_DPI_TAG=20250710-195309-241-8f9fb6d7
+DOCPROC_DPI_TAG=20250731-155328-257-06879e86
 DOCPROC_REGISTRY=
 
 # END -- IMAGE REGISTRIES AND TAGS
@@ -182,6 +185,7 @@ CALLBACK_HOST_URL=
 
 AGENTOPS_API_KEY_AUTH_ENABLED=true
 AGENTOPS_API_KEY=qwertyuiop
+FORCE_SINGLE_TENANT=true
 
 RUNTIME_MANAGER_API_KEY=example
 

ibm_watsonx_orchestrate/flow_builder/flows/__init__.py

@@ -1,6 +1,6 @@
 from .constants import START, END, RESERVED
 
-from ..types import FlowContext, TaskData, TaskEventType, File, DecisionsCondition, DecisionsRule
+from ..types import FlowContext, TaskData, TaskEventType, DocProcInput, DecisionsCondition, DecisionsRule
 from ..node import UserNode, AgentNode, StartNode, EndNode, PromptNode, ToolNode, DecisionsNode
 
 from .flow import Flow, CompiledFlow, FlowRun, FlowEvent, FlowEventType, FlowFactory, MatchPolicy, WaitPolicy, ForeachPolicy, Branch, Foreach, Loop
@@ -16,7 +16,7 @@ __all__ = [
     "FlowContext",
     "TaskData",
     "TaskEventType",
-    "File",
+    "DocProcInput",
 
     "DocProcNode",
     "UserNode",

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -18,7 +18,7 @@ import pytz
 import os
 
 from typing_extensions import Self
-from pydantic import BaseModel, Field, SerializeAsAny, create_model
+from pydantic import BaseModel, Field, SerializeAsAny, create_model, TypeAdapter
 import yaml
 from ibm_watsonx_orchestrate.agent_builder.tools.python_tool import PythonTool
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
@@ -27,7 +27,7 @@ from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ..types import (
     EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy, PromptLLMParameters, PromptNodeSpec, 
     StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy,
-    DocProcSpec, TextExtractionResponse, File, DecisionsNodeSpec, DecisionsRule, DocExtSpec, LanguageCode
+    DocProcSpec, TextExtractionResponse, DocProcInput, DecisionsNodeSpec, DecisionsRule, DocExtSpec, File
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
@@ -115,6 +115,10 @@ class Flow(Node):
                 # we need a deep compare if the incoming schema and existing_schema is the same
                 # pydantic suppport nested comparison by default
 
+                if isinstance(schema, dict):
+                    # recast schema to support direct access
+                    schema = JsonSchemaObject.model_validate(schema)
+
                 schema.title = title
 
                 if schema == existing_schema:
@@ -190,7 +194,7 @@ class Flow(Node):
     
     def _add_schema_ref(self, schema: JsonSchemaObject, title: str = None) -> SchemaRef:
         '''Create a schema reference'''
-        if schema and (schema.type == "object" or schema.type == "array"):
+        if schema and (schema.type == "object" or schema.type == "array" or schema.type == "string"):
             new_schema = self._add_schema(schema, title)
             return SchemaRef(ref=f"#/schemas/{new_schema.title}")
         raise AssertionError(f"schema is not a complex object: {schema}")
@@ -199,30 +203,31 @@ class Flow(Node):
         self._refactor_spec_to_schemaref(node.spec)
                 
     def _refactor_spec_to_schemaref(self, spec: NodeSpec):
-        if spec.input_schema:
+        if spec.input_schema and not isinstance(spec.input_schema, SchemaRef) and (spec.input_schema.type == "object" or spec.input_schema.type == "array") :
             if isinstance(spec.input_schema, ToolRequestBody):
                 spec.input_schema = self._add_schema_ref(JsonSchemaObject(type = spec.input_schema.type,
                                                                                 properties= spec.input_schema.properties,
                                                                                 required= spec.input_schema.required), 
                                                                 f"{spec.name}_input")
-        if spec.output_schema_object is not None and spec.output_schema_object.type == "object":
-            spec.output_schema = self._add_schema_ref(spec.output_schema_object, spec.output_schema_object.title)
-            spec.output_schema_object = None
-        elif spec.output_schema is not None:
-            if isinstance(spec.output_schema, ToolResponseBody):
-                if spec.output_schema.type == "object":
-                    json_obj = JsonSchemaObject(type = spec.output_schema.type,
-                            description=spec.output_schema.description,
-                            properties= spec.output_schema.properties,
-                            items = spec.output_schema.items,
-                            uniqueItems=spec.output_schema.uniqueItems,
-                            anyOf=spec.output_schema.anyOf,
-                            required= spec.output_schema.required)
-                    spec.output_schema = self._add_schema_ref(json_obj, f"{spec.name}_output")
-                elif spec.output_schema.type == "array":
-                    if hasattr(spec.output_schema, "items") and hasattr(spec.output_schema.items, "type") and spec.output_schema.items.type == "object":
-                        schema_ref = self._add_schema_ref(spec.output_schema.items)
-                        spec.output_schema.items = JsonSchemaObjectRef(ref=f"{schema_ref.ref}")
+        if not isinstance(spec.output_schema, SchemaRef):
+            if spec.output_schema_object is not None and spec.output_schema_object.type == "object":
+                spec.output_schema = self._add_schema_ref(spec.output_schema_object, spec.output_schema_object.title)
+                spec.output_schema_object = None
+            elif spec.output_schema is not None:
+                if isinstance(spec.output_schema, ToolResponseBody):
+                    if spec.output_schema.type == "object":
+                        json_obj = JsonSchemaObject(type = spec.output_schema.type,
+                                description=spec.output_schema.description,
+                                properties= spec.output_schema.properties,
+                                items = spec.output_schema.items,
+                                uniqueItems=spec.output_schema.uniqueItems,
+                                anyOf=spec.output_schema.anyOf,
+                                required= spec.output_schema.required)
+                        spec.output_schema = self._add_schema_ref(json_obj, f"{spec.name}_output")
+                    elif spec.output_schema.type == "array":
+                        if hasattr(spec.output_schema, "items") and hasattr(spec.output_schema.items, "type") and spec.output_schema.items.type == "object":
+                            schema_ref = self._add_schema_ref(spec.output_schema.items)
+                            spec.output_schema.items = JsonSchemaObjectRef(ref=f"{schema_ref.ref}")
 
     # def refactor_datamap_spec_to_schemaref(self, spec: FnDataMapSpec):
     #    '''TODO'''
@@ -535,7 +540,7 @@ class Flow(Node):
             "text_extraction" : TextExtractionResponse
         }
          # create input spec
-        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = File)
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = DocProcInput)
         output_schema_obj = _get_json_schema_obj("output", output_schema_dict[task])
         if "$defs" in output_schema_obj.model_extra:
             output_schema_obj.model_extra.pop("$defs")
@@ -1060,8 +1065,8 @@ class FlowFactory(BaseModel):
                 raise ValueError("Only functions with @flow_spec can be used to create a Flow specification.")
             return Flow(spec = flow_spec)
 
-        # create input spec
         input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = input_schema)
+        # create input spec
         output_schema_obj = _get_json_schema_obj("output", output_schema)
         if initiators is None:
             initiators = []