ibm-watsonx-orchestrate 1.8.1__py3-none-any.whl → 1.9.0__py3-none-any.whl

ibm_watsonx_orchestrate/docker/default.env

@@ -1,3 +1,7 @@
+# These credentials are for local development only.
+# They are default values and can be overridden by the user.
+# These do NOT provide access to any production or sensitive
+
 #DOCKER_IAM_KEY=dummy #Must Define in env
 #You can generate any JWT_SECRET with python -c 'import secrets; print(secrets.token_hex(32))'
 JWT_SECRET=11759cbc89dbec64956715e10a854eb38f8b7a1775bdf68142786170f5e8b5b2
@@ -53,27 +57,27 @@ EVENT_BROKER_TTL="3600"
 REGISTRY_URL=
 
 
-SERVER_TAG=22-07-2025
+SERVER_TAG=01-08-2025
 SERVER_REGISTRY=
 
-WORKER_TAG=22-07-2025
+WORKER_TAG=01-08-2025-v2
 WORKER_REGISTRY=
 
-AI_GATEWAY_TAG=21-07-2025
+AI_GATEWAY_TAG=01-08-2025-v1
 AI_GATEWAY_REGISTRY=
 
-AGENT_GATEWAY_TAG=07-07-2025
+AGENT_GATEWAY_TAG=29-07-2025
 AGENT_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=22-07-2025
-AMDDBTAG=24-06-2025-v1
-ARM64DBTAG=24-06-2025-v1
+DBTAG=29-07-2025-9f3661b
+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
@@ -84,33 +88,33 @@ TRM_REGISTRY=
 TR_TAG=23-07-2025-3c60549f0bac275de3e5736265a3fd49cdd3a203
 TR_REGISTRY=
 
-BUILDER_TAG=22-07-2025-v1
+BUILDER_TAG=31-07-2025-d7145cb
 BUILDER_REGISTRY=
 
-FLOW_RUNTIME_TAG=15-07-2025
+FLOW_RUNTIME_TAG=01-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=
 
 # IBM Document Processing
 WDU_TAG=2.5.0
 WDU_REGISTRY=
 
-DOCPROC_DPS_TAG=20250610-183301-248-865fbc1
-DOCPROC_LLMSERVICE_TAG=20250604-192056-107-e1d4d66
-DOCPROC_CACHE_TAG=20250610-214940-68-f3258f4
-DOCPROC_DPI_TAG=20250702-000808-237-7b1e424d
+DOCPROC_DPS_TAG=20250721-164412-250-503756a
+DOCPROC_LLMSERVICE_TAG=20250725-100249-111-51d3e51
+DOCPROC_CACHE_TAG=20250723-100852-70-9edc1ab
+DOCPROC_DPI_TAG=20250731-155328-257-06879e86
 DOCPROC_REGISTRY=
 
 # END -- IMAGE REGISTRIES AND TAGS
@@ -178,6 +182,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/constants.py

@@ -17,3 +17,5 @@ RESERVED = {
     ANY_USER,
     CURRENT_USER
 }
+
+

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -8,7 +8,7 @@ from datetime import datetime
 from enum import Enum
 import inspect
 from typing import (
-    Any, AsyncIterator, Callable, cast, List, Sequence, Union, Tuple
+    Any, AsyncIterator, Callable, Optional, cast, List, Sequence, Union, Tuple
 )
 import json
 import logging
@@ -18,7 +18,7 @@ import pytz
 import os
 
 from typing_extensions import Self
-from pydantic import BaseModel, Field, SerializeAsAny
+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,11 +27,11 @@ 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
+    DocProcSpec, TextExtractionResponse, DocProcInput, DecisionsNodeSpec, DecisionsRule, DocExtSpec, File
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
-    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode
+    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode
 )
 from ..types import (
     AgentNodeSpec, extract_node_spec, FlowContext, FlowEventType, FlowEvent, FlowSpec,
@@ -190,7 +190,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,7 +199,7 @@ 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 (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,
@@ -433,6 +433,50 @@ class Flow(Node):
         node = self._add_node(node)
         return cast(PromptNode, node)
     
+    def docext(self, 
+            name: str, 
+            llm : str = "meta-llama/llama-3-2-11b-vision-instruct",
+            version: str = "TIP",
+            display_name: str| None = None,
+            input_entities: type[BaseModel]| None = None, 
+            description: str | None = None,
+            input_map: DataMap = None) -> tuple[DocExtNode, type[BaseModel]]:
+        
+        if name is None :
+            raise ValueError("name must be provided.")
+
+        doc_ext_config = DocExtNode.generate_config(llm=llm, input_entites=input_entities)
+
+        DocExtFieldValue = DocExtNode.generate_docext_field_value_model(input_entities=input_entities)
+        
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = File)
+        output_schema_obj = _get_json_schema_obj("output", DocExtFieldValue)
+
+        if "$defs" in output_schema_obj.model_extra:
+            output_schema_obj.model_extra.pop("$defs")
+
+        # Create the docext spec
+        task_spec = DocExtSpec(
+            name=name,
+            display_name=display_name if display_name is not None else name,
+            description=description,
+            input_schema=_get_tool_request_body(input_schema_obj),
+            output_schema=_get_tool_response_body(output_schema_obj),
+            output_schema_object = output_schema_obj,
+            config=doc_ext_config,
+            version=version
+        )
+        node = DocExtNode(spec=task_spec)
+
+        # setup input map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+        
+        # add the node to the list of node
+        
+        node = self._add_node(node)
+        return cast(DocExtNode, node), DocExtFieldValue
+
     def decisions(self, 
             name: str, 
             display_name: str|None=None,
@@ -486,14 +530,12 @@ class Flow(Node):
         if name is None :
             raise ValueError("name must be provided.")
         
-        if task is None:
-            raise ValueError("task must be provided.")
         
         output_schema_dict = { 
             "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")
@@ -1018,8 +1060,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 = []

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -1,11 +1,14 @@
 import json
-from typing import Any, cast
+from typing import Any, cast, Type
 import uuid
 
 import yaml
-from pydantic import BaseModel, Field, SerializeAsAny
+from pydantic import BaseModel, Field, SerializeAsAny, create_model
+from enum import Enum
+
+from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
+                    DocExtSpec, DocExtConfig, LanguageCode, DecisionsNodeSpec
 
-from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, DecisionsNodeSpec
 from .data_map import DataMap
 
 class Node(BaseModel):
@@ -116,6 +119,34 @@ class DocProcNode(Node):
 
     def get_spec(self) -> DocProcSpec:
         return cast(DocProcSpec, self.spec)
+    
+class DocExtNode(Node):
+    def __repr__(self):
+        return f"DocExtNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> DocExtSpec:
+        return cast(DocExtSpec, self.spec)
+    
+    @staticmethod
+    def generate_config(llm: str, input_entites: type[BaseModel]) -> DocExtConfig:
+        entities = input_entites.__dict__.values()
+        return DocExtConfig(llm=llm, entities=entities)
+    
+    @staticmethod
+    def generate_docext_field_value_model(input_entities: type[BaseModel]) -> type[BaseModel]:
+        create_field_value_description = lambda field_name: "Extracted value for " + field_name
+
+        DocExtFieldValue = create_model(
+                "DocExtFieldValue",
+                    **{
+                        name: (str, Field(
+                            title=value['name'], 
+                            description=create_field_value_description(value['name']),
+                            )
+                        )
+                        for name, value in input_entities.model_dump().items()})
+        return DocExtFieldValue
+    
 class DecisionsNode(Node):
     def __repr__(self):
         return f"DecisionsNode(name='{self.spec.name}', description='{self.spec.description}')"

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -5,11 +5,14 @@ import numbers
 import inspect
 import logging
 from typing import (
-    Any, Callable, Self, cast, Literal, List, NamedTuple, Optional, Sequence, Union
+    Annotated, Any, Callable, Self, cast, Literal, List, NamedTuple, Optional, Sequence, Union, NewType
 )
+from typing_extensions import Doc
 
 import docstring_parser
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, GetCoreSchemaHandler, GetJsonSchemaHandler, RootModel
+from pydantic_core import core_schema
+from pydantic.json_schema import JsonSchemaValue
 
 from langchain_core.tools.base import create_schema_from_function
 from langchain_core.utils.json_schema import dereference_refs
@@ -86,7 +89,11 @@ def _to_json_from_input_schema(schema: Union[ToolRequestBody, SchemaRef]) -> dic
             model_spec["properties"] = {}
             for prop_name, prop_schema in request_body.properties.items():
                 model_spec["properties"][prop_name] = _to_json_from_json_schema(prop_schema)
-        model_spec["required"] = request_body.required
+        model_spec["required"] = request_body.required if request_body.required else []
+        if schema.model_extra:
+            for k, v in schema.model_extra.items():
+                model_spec[k] = v
+        
     elif isinstance(schema, SchemaRef):
         model_spec["$ref"] = schema.ref
     
@@ -163,14 +170,99 @@ class NodeSpec(BaseModel):
 
         return model_spec
 
+class DocExtConfigEntity(BaseModel):
+    name: str = Field(description="Entity name")
+    type: Literal["string", "date", "number"] = Field(default="string",  description="The type of the entity values")
+    description: str = Field(title="Description", description="Description of the entity", default="")
+    field_name: str = Field(title="Field Name", description="The normalized name of the entity", default="")
+    multiple_mentions: bool = Field(title="Multiple mentions",description="When true, we can produce multiple mentions of this entity", default=False)
+    example_value: str = Field(description="Value of example", default="")
+    examples: list[str] = Field(title="Examples", description="Examples that help the LLM understand the expected entity mentions", default=[])
+
+class DocExtConfig(BaseModel):
+    domain: str = Field(description="Domiain of the document", default="other")
+    type: str = Field(description="Document type", default="agreement")
+    llm: str = Field(description="The LLM used for the document extraction", default="meta-llama/llama-3-2-11b-vision-instruct")
+    entities: list[DocExtConfigEntity] = Field(default=[])
+
+class LanguageCode(StrEnum):
+    en = auto()
+    fr = auto()
+
+class DocProcCommonNodeSpec(NodeSpec):
+    enable_hw: bool | None = Field(description="Boolean value indicating if hand-written feature is enabled.", title="Enable handwritten", default=False)
+
+class DocExtSpec(DocProcCommonNodeSpec):
+    version : str = Field(description="A version of the spec")
+    config : DocExtConfig
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.kind = "docext"
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        model_spec["version"] = self.version
+        model_spec["config"] = self.config.model_dump()
+        return model_spec
+    
+class DocProcField(BaseModel):
+    description: str = Field(description="A description of the field to extract from the document.")
+    example: str = Field(description="An example of the field to extract from the document.", default='')
+    default: Optional[str] = Field(description="A default value for the field to extract from the document.", default='')
+
+class DocProcTable(BaseModel):
+    type: Literal["array"]
+    description: str = Field(description="A description of the table to extract from the document.")
+    columns: dict[str,DocProcField] = Field(description="The columns to extract from the table. These are the keys in the table extraction result.")
+
+class DocProcKVPSchema(BaseModel):
+    document_type: str = Field(description="A label for the kind of documents we want to extract")
+    document_description: str = Field(description="A description of the kind of documents we want to extractI. This is used to select which schema to use for extraction.")
+    fields: dict[str, DocProcField | DocProcTable] = Field(description="The fields to extract from the document. These are the keys in the KVP extraction result.")
+
+class DocProcBoundingBox(BaseModel):
+    x: float = Field(description="The x coordinate of the bounding box.")
+    y: float = Field(description="The y coordinate of the bounding box.")
+    width: float = Field(description="The width of the bounding box.")
+    height: float = Field(description="The height of the bounding box.")
+    page_number: int = Field(description="The page number of the bounding box in the document.")
+
+class KVPBaseEntry(BaseModel):
+    id: str = Field(description="A unique identifier.")
+    raw_text: str = Field(description="The raw text.")
+    normalized_text: Optional[str] = Field(description="The normalized text.", default=None)
+    confidence_score: Optional[float] = Field(description="The confidence score.", default=None)
+    bbox: Optional[DocProcBoundingBox] = Field(description="The bounding box in the document.", default=None)
+    
+class DocProcKey(KVPBaseEntry):
+    semantic_label: str = Field(description="A semantic label for the key.")
+
+class DocProcValue(KVPBaseEntry):
+    pass
+
+class DocProcKVP(BaseModel):
+    id: str = Field(description="A unique identifier for the key-value pair.")
+    type: Literal["key_value","only_value"]
+    key: DocProcKey = Field(description="The key of the key-value pair.")
+    value: DocProcValue = Field(description="The value of the key-value pair.")
+    group_id: Optional[str] = Field(default=None, description="The group id of the key-value pair. This is used to group key-value pairs together.")
+    table_id: Optional[str] = Field(default=None, description="The table id of the key-value pair. This is used to group key-value pairs together in a table.")
+    table_name: Optional[str] = Field(default=None, description="The name of the table the key-value pair belongs to. This is used to group key-value pairs together in a table.")
+    table_row_index: Optional[int] = Field(default=None, description="The index of the row in the table the key-value pair belongs to. This is used to group key-value pairs together in a table.")
+
 class DocProcTask(StrEnum):
     '''
     Possible names for the Document processing task parameter
     '''
     text_extraction = auto()
 
-class DocProcSpec(NodeSpec):
+class DocProcSpec(DocProcCommonNodeSpec):
     task: DocProcTask = Field(description='The document processing operation name', default=DocProcTask.text_extraction)
+    kvp_schema: List[DocProcKVPSchema] | None = Field(
+        title='KVP schemas',
+        description="Optional list of key-value pair schemas to use for extraction.",
+        default=None)
     
     def __init__(self, **data):
         super().__init__(**data)
@@ -673,6 +765,7 @@ class TaskEventType(Enum):
     ON_TASK_END = "task:on_task_end"
     ON_TASK_STREAM = "task:on_task_stream"
     ON_TASK_ERROR = "task:on_task_error"
+    ON_TASK_RESUME= "task:on_task_resume"
 
 class FlowData(BaseModel):
     '''This class represents the data that is passed between tasks in a flow.'''
@@ -707,7 +800,7 @@ class FlowEventType(Enum):
     ON_FLOW_START = "flow:on_flow_start"
     ON_FLOW_END = "flow:on_flow_end"
     ON_FLOW_ERROR = "flow:on_flow_error"
-
+    ON_FLOW_RESUME = "flow:on_flow_resume"
 
 @dataclass
 class FlowEvent:
@@ -743,41 +836,67 @@ class LanguageCode(StrEnum):
     fr = auto()
     en_hw = auto()
 
-class File(BaseModel):
+
+class File(str):
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.no_info_wrap_validator_function(
+            cls.validate,
+            core_schema.str_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(lambda v: str(v))
+        )
+
+    @classmethod
+    def validate(cls, value: Any) -> "File":
+        if not isinstance(value, str):
+            raise TypeError("File must be a document reference (string)")
+        return cls(value)
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        return {
+            "type": "string",
+            "title": "Document reference",
+            "format": "binary",
+            "description": "Either an ID or a URL identifying the document to be used.",
+            "wrap_data": False,
+            "required": []
+        }
+    
+class DocExtInput(BaseModel):
+    document_ref: bytes | File = Field(description="Either an ID or a URL identifying the document to be used.", title='Document reference', default=None, json_schema_extra={"format": "binary"})
+
+
+class DocProcInput(BaseModel):
     '''
     This class represents the input of a Document processing task. 
 
     Attributes:
         document_ref (bytes|str): This is either a URL to the location of the document bytes or an ID that we use to resolve the location of the document
         language (LanguageCode): Optional language code used when processing the input document
+        kvp_schemas (List[DocProcKVPSchema]): Optional list of key-value pair schemas to use for extraction. If not provided or None, no KVPs will be extracted. If an empty list is provided, we will use the internal schemas to extract KVPS.
     '''
     # This is declared as bytes but the runtime will understand if a URL is send in as input.
     # We need to use bytes here for Chat-with-doc to recognize the input as a File.
-    document_ref: bytes | str = Field(
-        description="Either an ID or a URL identifying the document to be used.", 
-        title='Document reference', 
-        default=None, 
-        json_schema_extra={"format": "binary"})
-    language: Optional[LanguageCode] = Field(
-        description='Optional language code of the document, defaults to "en"', 
-        title='Document language code', 
-        default=LanguageCode.en)
-
-class TextExtraction(BaseModel):
-    '''
-    This class represents the output generated by a "text_extraction" document processing (docproc) operation.
-    Attributes:
-        text (str): the text extracted from the input document.
-    '''
-    text: str = Field(description='The text extracted from the input document', title='Text extraction')
+    document_ref: bytes | File = Field(description="Either an ID or a URL identifying the document to be used.", title='Document reference', default=None, json_schema_extra={"format": "binary"})
+    kvp_schemas: Optional[List[DocProcKVPSchema]] = Field(
+        title='KVP schemas',
+        description="Optional list of key-value pair schemas to use for extraction.",
+        default=None)
 
 class TextExtractionResponse(BaseModel):
     '''
     The text extraction operation response.
     Attributes:
-        output (TextExtraction): a wrapper for the text extraction response
+        text (str): the text extracted from the input document.
+        kvps (Optional[list[DocProcKVP]]): A list of key-value pairs extracted from the document. If no KVPs were extracted, this will be None.
     '''
-    output: TextExtraction = Field(description='The text extraction response')
+    text: str = Field(description='The text extracted from the input document', title='text')
+    kvps: Optional[list[DocProcKVP]] = Field(description="A list of key-value pairs extracted from the document.", default=None)
 
 
 class DecisionsCondition(BaseModel):

ibm_watsonx_orchestrate/flow_builder/utils.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel, TypeAdapter
 
 from langchain_core.utils.json_schema import dereference_refs
 import typer
-import yaml
 
 from ibm_watsonx_orchestrate.agent_builder.tools.base_tool import BaseTool
 from ibm_watsonx_orchestrate.agent_builder.tools.flow_tool import create_flow_json_tool
@@ -90,9 +89,13 @@ def _get_tool_request_body(schema_obj: JsonSchemaObject) -> ToolRequestBody:
             request_obj = ToolRequestBody(type='object', properties=schema_obj.properties, required=schema_obj.required)
             if schema_obj.model_extra:
                 request_obj.__pydantic_extra__ = schema_obj.model_extra
-        else:  # we need to wrap a simple type with an object
-            request_obj = ToolRequestBody(type='object', properties={}, required=[])
-            request_obj.properties["data"] = schema_obj
+        else:  
+            if schema_obj.wrap_data:
+                # we need to wrap a simple type with an object
+                request_obj = ToolRequestBody(type='object', properties={}, required=[])
+                request_obj.properties["data"] = schema_obj
+            else:
+                request_obj = ToolRequestBody(type=schema_obj.type, title=schema_obj.title, description=schema_obj.description, format=schema_obj.format)
             if schema_obj.model_extra:
                 request_obj.__pydantic_extra__ = schema_obj.model_extra
 

{ibm_watsonx_orchestrate-1.8.1.dist-info → ibm_watsonx_orchestrate-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.8.1
+Version: 1.9.0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License