ibm-watsonx-orchestrate 1.6.2__py3-none-any.whl → 1.7.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -15,6 +15,7 @@ import logging
 import copy
 import uuid
 import pytz
+import os
 
 from typing_extensions import Self
 from pydantic import BaseModel, Field, SerializeAsAny
@@ -25,11 +26,13 @@ from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 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
+    StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy,
+    DocProcSpec, TextExtractionResponse, KVPInvoicesExtractionResponse, KVPUtilityBillsExtractionResponse,
+    DocumentContent
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
-    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode
+    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode
 )
 from ..types import (
     AgentNodeSpec, extract_node_spec, FlowContext, FlowEventType, FlowEvent, FlowSpec,
@@ -114,7 +117,7 @@ class Flow(Node):
                 # pydantic suppport nested comparison by default
 
                 schema.title = title
-                
+
                 if schema == existing_schema:
                     return existing_schema
                 # we need to do a deep compare
@@ -354,6 +357,7 @@ class Flow(Node):
               name: str, 
               agent: str, 
               display_name: str|None=None,
+              title: str | None = None,
               message: str | None = "Follow the agent instructions.",
               description: str | None = None,
               input_schema: type[BaseModel]|None = None, 
@@ -371,6 +375,7 @@ class Flow(Node):
             display_name=display_name,
             description=description,
             agent=agent,
+            title=title,
             message=message,
             guidelines=guidelines,
             input_schema=_get_tool_request_body(input_schema_obj),
@@ -428,6 +433,50 @@ class Flow(Node):
         # add the node to the list of node
         node = self._add_node(node)
         return cast(PromptNode, node)
+    
+    def docproc(self, 
+            name: str, 
+            task: str,
+            display_name: str|None=None,
+            description: str | None = None,
+            input_map: DataMap = None) -> DocProcNode:
+
+        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,
+            "kvp_invoices_extraction" : KVPInvoicesExtractionResponse,
+            "kvp_utility_bills_extraction" : KVPUtilityBillsExtractionResponse
+        }
+         # create input spec
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = DocumentContent)
+        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")
+        # Create the docproc spec
+        task_spec = DocProcSpec(
+            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,
+            task=task
+        )
+
+        node = DocProcNode(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(DocProcNode, node)
+    
 
     def node_exists(self, node: Union[str, Node]):
      
@@ -921,7 +970,8 @@ class FlowFactory(BaseModel):
                     description: str|None=None,
                     initiators: Sequence[str]|None=None,
                     input_schema: type[BaseModel]|None=None,
-                    output_schema: type[BaseModel]|None=None) -> Flow:
+                    output_schema: type[BaseModel]|None=None,
+                    schedulable: bool=False) -> Flow:
         if isinstance(name, Callable):
             flow_spec = getattr(name, "__flow_spec__", None)
             if not flow_spec:
@@ -942,7 +992,8 @@ class FlowFactory(BaseModel):
             initiators=initiators,
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
-            output_schema_object = output_schema_obj
+            output_schema_object = output_schema_obj,
+            schedulable=schedulable,
         )
 
         return Flow(spec = flow_spec)
@@ -1228,10 +1279,12 @@ class UserFlow(Flow):
               kind: UserFieldKind = UserFieldKind.Text,
               display_name: str | None = None,
               description: str | None = None,
-              owners: list[str] = [],
               default: Any | None = None,
-              text: str = None,
+              text: str = None, # The text used to ask question to the user, e.g. 'what is your name?'
               option: UserFieldOption | None = None,
+              is_list: bool = False,
+              min: Any | None = None,
+              max: Any | None = None,
               input_map: DataMap = None,
               custom: dict[str, Any] = {}) -> UserNode:
         '''create a node in the flow'''
@@ -1246,20 +1299,42 @@ class UserFlow(Flow):
         schema_obj.properties = {}
         schema_obj.properties[name] = UserFieldKind.convert_kind_to_schema_property(kind, name, description, default, option, custom)
 
-        return self.user(name, 
-                         display_name=display_name,
-                         description=description,
-                         owners=owners,
-                         text=text,
-                         output_schema=schema_obj,
-                         input_map=input_map)
+        task_spec = UserNodeSpec(
+            name=name,
+            display_name=display_name,
+            description=description,
+            owners=[CURRENT_USER],
+            input_schema=_get_tool_request_body(schema_obj),
+            output_schema=_get_tool_response_body(schema_obj),
+            text=text,
+            output_schema_object = schema_obj
+        )
+
+        node = UserNode(spec = task_spec)
+        node.field(name = name,
+                   kind = kind,
+                   display_name = display_name,
+                   description = description,
+                   default = default,
+                   text = text,
+                   option = option,
+                   is_list = is_list,
+                   min = min,
+                   max = max,
+                   custom = custom)
+
+        # setup input map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+
+        node = self._add_node(node)
+        return cast(UserNode, node)
 
     def user(
         self,
         name: str | None = None,
         display_name: str | None = None,
         description: str | None = None,
-        owners: list[str] = [],
         text: str | None = None,
         output_schema: type[BaseModel] | JsonSchemaObject| None = None,
         input_map: DataMap = None,
@@ -1273,16 +1348,12 @@ class UserFlow(Flow):
         # input and output is always the same in an user node
         output_schema_obj = output_schema_obj
 
-        # identify owner
-        if not owners:
-            owners = [ANY_USER]
-
         # Create the tool spec
         task_spec = UserNodeSpec(
             name=name,
             display_name=display_name,
             description=description,
-            owners=owners,
+            owners=[CURRENT_USER],
             input_schema=_get_tool_request_body(output_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
             text=text,

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -5,7 +5,7 @@ import uuid
 import yaml
 from pydantic import BaseModel, Field, SerializeAsAny
 
-from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec
+from .types import EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec
 from .data_map import DataMap
 
 class Node(BaseModel):
@@ -78,6 +78,8 @@ class UserNode(Node):
               description: str | None = None,
               default: Any | None = None,
               option: UserFieldOption | None = None,
+              min: Any | None = None,
+              max: Any | None = None,
               is_list: bool = False,
               custom: dict[str, Any] | None = None,
               widget: str | None = None):
@@ -88,6 +90,8 @@ class UserNode(Node):
                               description=description,
                               default=default,
                               option=option,
+                              min=min,
+                              max=max,
                               is_list=is_list,
                               custom=custom,
                               widget=widget)
@@ -105,6 +109,13 @@ class PromptNode(Node):
 
     def get_spec(self) -> PromptNodeSpec:
         return cast(PromptNodeSpec, self.spec)
+    
+class DocProcNode(Node):
+    def __repr__(self):
+        return f"DocProcNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> DocProcSpec:
+        return cast(DocProcSpec, self.spec)
 
 class NodeInstance(BaseModel):
     node: Node

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, StrEnum, auto
 import inspect
 import logging
 from typing import (
@@ -116,7 +116,7 @@ def _to_json_from_output_schema(schema: Union[ToolResponseBody, SchemaRef]) -> d
     return model_spec
 
 class NodeSpec(BaseModel):
-    kind: Literal["node", "tool", "user", "agent", "flow", "start", "decisions", "prompt", "branch", "wait", "foreach", "loop", "userflow", "end"] = "node"
+    kind: Literal["node", "tool", "user", "agent", "flow", "start", "decisions", "prompt", "branch", "wait", "foreach", "loop", "userflow", "end", "docproc" ] = "node"
     name: str
     display_name: str | None = None
     description: str | None = None
@@ -162,6 +162,26 @@ class NodeSpec(BaseModel):
 
         return model_spec
 
+class DocProcTask(StrEnum):
+    '''
+    Possible names for the Document processing task parameter
+    '''
+    text_extraction = auto()
+    kvp_invoices_extraction = auto()
+    kvp_utility_bills_extraction = auto()
+
+class DocProcSpec(NodeSpec):
+    task: DocProcTask = Field(description='The document processing operation name', default=DocProcTask.text_extraction)
+    
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.kind = "docproc"
+
+    def to_json(self) -> dict[str, Any]:
+        model_spec = super().to_json()
+        model_spec["task"] = self.task
+        return model_spec
+    
 class StartNodeSpec(NodeSpec):
     def __init__(self, **data):
         super().__init__(**data)
@@ -296,6 +316,8 @@ class UserField(BaseModel):
     description: str | None = None
     default: Any | None = None
     option: UserFieldOption | None = None
+    min: Any | None = None,
+    max: Any | None = None,
     is_list: bool = False
     custom: dict[str, Any] | None = None
     widget: str | None = None
@@ -314,6 +336,10 @@ class UserField(BaseModel):
             model_spec["description"] = self.description
         if self.default:
             model_spec["default"] = self.default
+        if self.min:
+            model_spec["min"] = self.min
+        if self.max:
+            model_spec["min"] = self.max
         if self.is_list:
             model_spec["is_list"] = self.is_list
         if self.option:
@@ -356,7 +382,10 @@ class UserNodeSpec(NodeSpec):
               display_name: str | None = None, 
               description: str | None = None, 
               default: Any | None = None, 
-              option: list[str] | None = None, is_list: bool = False,
+              option: list[str] | None = None, 
+              min: Any | None = None,
+              max: Any | None = None,
+              is_list: bool = False,
               custom: dict[str, Any] | None = None,
               widget: str | None = None):
         userfield = UserField(name=name, 
@@ -366,6 +395,8 @@ class UserNodeSpec(NodeSpec):
                               description=description, 
                               default=default, 
                               option=option, 
+                              min=min,
+                              max=max,
                               is_list=is_list,
                               custom=custom,
                               widget=widget)
@@ -402,6 +433,8 @@ class UserNodeSpec(NodeSpec):
                                              default=prop_schema.default,
                                              option=self.setup_field_options(prop_schema.title, prop_schema.enum),
                                              is_list=prop_schema.type == "array",
+                                             min=prop_schema.minimum,
+                                             max=prop_schema.maximum,
                                              custom=prop_schema.model_extra))
 
     def setup_field_options(self, name: str, enums: List[str]) -> UserFieldOption:
@@ -415,6 +448,7 @@ class UserNodeSpec(NodeSpec):
 
 class AgentNodeSpec(ToolNodeSpec):
     message: str | None = Field(default=None, description="The instructions for the task.")
+    title: str | None = Field(default=None, description="The title of the message.")
     guidelines: str | None = Field(default=None, description="The guidelines for the task.")
     agent: str
 
@@ -430,6 +464,8 @@ class AgentNodeSpec(ToolNodeSpec):
             model_spec["guidelines"] = self.guidelines
         if self.agent:
             model_spec["agent"] = self.agent
+        if self.title:
+            model_spec["title"] = self.title
         return model_spec
 
 class PromptLLMParameters(BaseModel):
@@ -553,10 +589,9 @@ class WaitNodeSpec(FlowControlNodeSpec):
         return my_dict
 
 class FlowSpec(NodeSpec):
- 
-
     # who can initiate the flow
     initiators: Sequence[str] = [ANY_USER]
+    schedulable: bool = False
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -566,6 +601,8 @@ class FlowSpec(NodeSpec):
         model_spec = super().to_json()
         if self.initiators:
             model_spec["initiators"] = self.initiators
+        
+        model_spec["schedulable"] = self.schedulable
 
         return model_spec
 
@@ -631,11 +668,11 @@ class TaskData(NamedTuple):
 
 class TaskEventType(Enum):
  
-    ON_TASK_WAIT = "on_task_wait" # the task is waiting for inputs before proceeding
-    ON_TASK_START = "on_task_start"
-    ON_TASK_END = "on_task_end"
-    ON_TASK_STREAM = "on_task_stream"
-    ON_TASK_ERROR = "on_task_error"
+    ON_TASK_WAIT = "task:on_task_wait" # the task is waiting for inputs before proceeding
+    ON_TASK_START = "task:on_task_start"
+    ON_TASK_END = "task:on_task_end"
+    ON_TASK_STREAM = "task:on_task_stream"
+    ON_TASK_ERROR = "task:on_task_error"
 
 class FlowData(BaseModel):
     '''This class represents the data that is passed between tasks in a flow.'''
@@ -667,9 +704,9 @@ class FlowContext(BaseModel):
     
 class FlowEventType(Enum):
  
-    ON_FLOW_START = "on_flow_start"
-    ON_FLOW_END = "on_flow_end"
-    ON_FLOW_ERROR = "on_flow_error"
+    ON_FLOW_START = "flow:on_flow_start"
+    ON_FLOW_END = "flow:on_flow_end"
+    ON_FLOW_ERROR = "flow:on_flow_error"
 
 
 @dataclass
@@ -691,9 +728,125 @@ class Assignment(BaseModel):
             e.g. "node.input.name" or "=f'{node.output.name}_{node.output.id}'"
 
     '''
-    target: str
-    source: str
-    
+    target_variable: str
+    value_expression: str | None = None
+    has_no_value: bool = False
+    default_value: Any | None = None
+    metadata: dict = Field(default_factory=dict[str, Any])
+
+class LanguageCode(StrEnum):
+    '''
+    The ISO-639 language codes understood by Document Processing functions.
+    A special 'en_hw' code is used to enable an English handwritten model.
+    '''
+    en = auto()
+    fr = auto()
+    en_hw = auto()
+
+class DocumentContent(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
+    '''
+    # 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 Document.
+    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')
+
+class TextExtractionResponse(BaseModel):
+    '''
+    The text extraction operation response.
+    Attributes:
+        output (TextExtraction): a wrapper for the text extraction response
+    '''
+    output: TextExtraction = Field(description='The text extraction response')
+
+class Invoice(BaseModel):
+    '''
+    This class represents the fields extracted by the "kvp_invoices_extraction" document processing (docproc) operation.
+    '''
+    bank_account_number: Optional[str] = Field(title='Bank account number', default=None)
+    bank_name: Optional[str] = Field(title='Bank name', default=None)
+    bill_to_address: Optional[str] = Field(title='Bill-to address', default=None)
+    bill_to_name: Optional[str] = Field(title='Bill-to name', default=None)
+    invoice_date: Optional[str] = Field(title='Invoice date', format='date', default=None)
+    invoice_number: Optional[str] = Field(title='Invoice number', default=None)
+    invoice_total: Optional[float] = Field(title='Invoice total', default=None)
+    payment_due_date: Optional[str] = Field(title='Payment due date', format='date', default=None)
+    payment_terms: Optional[str] = Field(title='Payment terms', default=None)
+    purchase_order_number: Optional[str] = Field(title='Purchase order number', default=None)
+    ship_to_address: Optional[str] = Field(title='Ship-to address', default=None)
+    ship_to_name: Optional[str] = Field(title='Ship-to name', default=None)
+    shipping_amount: Optional[float] = Field(title='Shipping amount', default=None)
+    subtotal: Optional[float] = Field(title='Subtotal', default=None)
+    tax_amount: Optional[float] = Field(title='Tax amount', default=None)
+    tax_rate: Optional[float] = Field(title='Tax rate', default=None)
+    tax_type: Optional[str] = Field(title='Tax type', default=None)
+    vendor_address: Optional[str] = Field(title='Vendor address', default=None)
+    vendor_name: Optional[str] = Field(title='Vendor name', default=None)
+
+
+class KVPInvoicesExtractionResponse(BaseModel):
+    '''
+    The response of a "kvp_invoices_extraction" document processing (docproc) operation.
+    Attributes:
+        invoice: an object with the fields extracted from the input invoice document
+    '''
+    output: Invoice = Field(
+        title='Invoice',
+        description='The fields extracted from an invoice document'
+    )
+
+
+class UtilityBill(BaseModel):
+    '''
+    This class represents the fields extracted by the "kvp_utility_bills_extraction" document processing (docproc) operation.
+    '''
+    account_number: Optional[str] = Field(title='Account number', default=None)
+    amount_due: Optional[float] = Field(title='Amount due', default=None)
+    client_number: Optional[str] = Field(title='Client number', default=None)
+    company_name: Optional[str] = Field(title='Company name', default=None)
+    company_address: Optional[str] = Field(title='Company address', default=None)
+    customer_name: Optional[str] = Field(title='Customer name', default=None)
+    customer_address: Optional[str] = Field(title='Customer address', default=None)
+    due_date: Optional[str] = Field(title='Due date', format='date', default=None)
+    payment_received: Optional[float] = Field(title='Payment received', default=None)
+    previous_balance: Optional[float] = Field(title='Previous balance', default=None)
+    service_address: Optional[str] = Field(title='Service address', default=None)
+    statement_date: Optional[str] = Field(title='Statement date', format='date', default=None)
+
+#class UtilityBillResponse(BaseModel):
+#    field_value: UtilityBill = Field(title='Field value')
+
+class KVPUtilityBillsExtractionResponse(BaseModel):
+    '''
+    The response of a "kvp_utility_bills_extraction" document processing (docproc) operation.
+    Attributes:
+        utility_bull: an object with the fields extracted from the input utility bill document
+    '''
+    output: UtilityBill = Field(
+        title='Utility bill',
+        description='The fields extracted from a utility bill document'
+    )
+
 def extract_node_spec(
         fn: Callable | PythonTool,
         name: Optional[str] = None,

ibm_watsonx_orchestrate/flow_builder/utils.py

@@ -87,9 +87,15 @@ def _get_tool_request_body(schema_obj: JsonSchemaObject) -> ToolRequestBody:
         return None
     
     if isinstance(schema_obj, JsonSchemaObject):
-        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
+        if schema_obj.type == "object":
+            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
+            if schema_obj.model_extra:
+                request_obj.__pydantic_extra__ = schema_obj.model_extra
 
         return request_obj
     
@@ -162,17 +168,27 @@ async def import_flow_model(model):
 
     return tool_id
 
-def import_flow_support_tools():
+def import_flow_support_tools(model):
 
     if not is_local_dev():
         # we can't import support tools into non-local environments yet
         return []
 
+        
+    schedulable = False
+    if "schedulable" in model["spec"]:
+        schedulable = model["spec"]["schedulable"]
+
     client = instantiate_client(TempusClient)
 
     logger.info(f"Import 'get_flow_status' tool spec...")
     tools = [create_flow_status_tool("i__get_flow_status_intrinsic_tool__")]
 
+    if schedulable:
+        get_schedule_tool = create_get_schedule_tool("i__get_schedule_intrinsic_tool__")
+        delete_schedule_tool = create_delete_schedule_tool("i__delete_schedule_intrinsic_tool__")
+        tools.extend([get_schedule_tool, delete_schedule_tool])
+
     return tools
 
 # Assisted by watsonx Code Assistant
@@ -187,7 +203,7 @@ def create_flow_status_tool(flow_status_tool: str, TEMPUS_ENDPOINT: str="http://
     )
 
     openapi_binding = OpenApiToolBinding(
-        http_path="/flows",
+        http_path="/v1/flows",
         http_method="GET",
         security=[],
         servers=[TEMPUS_ENDPOINT]
@@ -213,3 +229,102 @@ def create_flow_status_tool(flow_status_tool: str, TEMPUS_ENDPOINT: str="http://
 
     return OpenAPITool(spec=spec)
 
+
+def create_get_schedule_tool(name: str, TEMPUS_ENDPOINT: str="http://wxo-tempus-runtime:9044") -> dict:
+
+    spec = ToolSpec(
+        name=name,
+        description="Use this tool to show the current schedules.",
+        permission='read_only',
+        display_name= "Get Schedules"
+    )
+
+    openapi_binding = OpenApiToolBinding(
+        http_path="/v1/schedules/simple",
+        http_method="GET",
+        security=[],
+        servers=[TEMPUS_ENDPOINT]
+    )
+    
+    spec.binding = ToolBinding(openapi=openapi_binding)
+    # Input Schema
+    properties = {
+        "query_schedule_id": {
+            "type": "string",
+            "title": "schedule_id",
+            "description": "Identifies the schedule instance.",
+            "in": "query"
+        },
+        "query_schedule_name": {
+            "type": "string",
+            "title": "schedule_name",
+            "description": "Identifies the schedule name.",
+            "in": "query"
+        },
+    }
+    
+    spec.input_schema = ToolRequestBody(
+        type='object',
+        properties=properties,
+        required=[]
+    )
+
+    response_properties = {
+        "schedule_id": {
+            "type": "string",
+        },
+        "schedule_name": {
+            "type": "string",
+        },
+        "schedule_data": {
+            "type": "string",
+        },
+        "schedule_time": {
+            "type": "string",
+        }
+    }
+
+    spec.output_schema = ToolResponseBody(type='object',
+                                          properties=response_properties,
+                                          description='Return the information about the schedule.')
+
+    return OpenAPITool(spec=spec)
+
+
+def create_delete_schedule_tool(name: str, TEMPUS_ENDPOINT: str="http://wxo-tempus-runtime:9044") -> dict:
+
+    spec = ToolSpec(
+        name=name,
+        description="Use this tool to delete/remove a schedule based on the schedule_id.",
+        permission='read_only',
+        display_name= "Delete Schedule"
+    )
+
+    openapi_binding = OpenApiToolBinding(
+        http_path="/v1/schedules/{schedule_id}",
+        http_method="DELETE",
+        security=[],
+        servers=[TEMPUS_ENDPOINT]
+    )
+    
+    spec.binding = ToolBinding(openapi=openapi_binding)
+    # Input Schema
+    properties = {
+        "path_schedule_id": {
+            "type": "string",
+            "title": "schedule_id",
+            "description": "Identifies the schedule instance.",
+            "in": "query"
+        }
+    }
+    
+    spec.input_schema = ToolRequestBody(
+        type='object',
+        properties=properties,
+        required=[]
+    )
+
+    spec.output_schema = ToolResponseBody(type='object',
+                                          description='Schedule deleted.')
+
+    return OpenAPITool(spec=spec)