writer 0.8.3rc4__py3-none-any.whl → 1.25.1rc1__py3-none-any.whl

writer/blocks/parsejson.py

@@ -1,48 +1,49 @@
 import json
 
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate
 
 
-class ParseJSON(WorkflowBlock):
-
+class ParseJSON(BlueprintBlock):
     @classmethod
     def register(cls, type: str):
         super(ParseJSON, cls).register(type)
-        register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
-            writer={
-                "name": "Parse JSON",
-                "description": "Parses a JSON string.",
-                "category": "Other",
-                "fields": {
-                    "plainText": {
-                        "name": "Plain text",
-                        "type": "Text",
-                        "control": "Textarea"
-                    },
-                },
-                "outs": {
-                    "success": {
-                        "name": "Success",
-                        "description": "The request was successful.",
-                        "style": "success",
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Parse JSON",
+                    "description": "Converts a JSON string into an object, so you can work with it in your logic.",
+                    "category": "Other",
+                    "fields": {
+                        "plainText": {"name": "Plain text", "type": "Text", "control": "Textarea"},
                     },
-                    "error": {
-                        "name": "Error",
-                        "description": "The text provided couldn't be parsed.",
-                        "style": "error",
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The request was successful.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "The text provided couldn't be parsed.",
+                            "style": "error",
+                        },
                     },
                 },
-            }
-        ))
+            ),
+        )
 
     def run(self):
         try:
             plain_text = self._get_field("plainText")
-            self.result = json.loads(plain_text)
+            if isinstance(plain_text, dict):
+                self.result = plain_text
+            else:
+                self.result = json.loads(plain_text)
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e

writer/blocks/returnvalue.py

@@ -1,18 +1,18 @@
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 
-class ReturnValue(WorkflowBlock):
+class ReturnValue(BlueprintBlock):
 
     @classmethod
     def register(cls, type: str):
         super(ReturnValue, cls).register(type)
         register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
+            baseType="blueprints_node",
             writer={
                 "name": "Return value",
-                "description": "Returns a value from a workflow or sub-workflow.",
+                "description": "Returns a value from this block to the caller. Use to pass results to another blueprint.",
                 "category": "Logic",
                 "fields": {
                     "value": {
@@ -24,12 +24,12 @@ class ReturnValue(WorkflowBlock):
                 "outs": {
                     "success": {
                         "name": "Success",
-                        "description": "If the function doesn't raise an Exception.",
+                        "description": "The value was returned successfully.",
                         "style": "success",
                     },
                     "error": {
                         "name": "Error",
-                        "description": "If the function raises an Exception.",
+                        "description": "There was an error returning the value.",
                         "style": "error",
                     },
                 },
@@ -46,4 +46,4 @@ class ReturnValue(WorkflowBlock):
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e

writer/blocks/runblueprint.py

@@ -0,0 +1,63 @@
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import BlueprintBlock
+from writer.ss_types import AbstractTemplate
+
+
+class RunBlueprint(BlueprintBlock):
+    @classmethod
+    def register(cls, type: str):
+        super(RunBlueprint, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Run blueprint",
+                    "description": "Starts another blueprint by key. Useful for breaking logic into smaller, reusable parts.",
+                    "category": "Logic",
+                    "fields": {
+                        "blueprintKey": {
+                            "name": "Blueprint Key",
+                            "type": "Blueprint Key",
+                            "validator": {
+                                "type": "string",
+                                "format": "writer#blueprintKey",
+                            },
+                        },
+                        "payload": {
+                            "name": "Payload",
+                            "desc": "The value specified will be available using the template syntax, e.g. @{payload}.",
+                            "default": "{}",
+                            "type": "Text",
+                            "control": "Textarea",
+                        },
+                    },
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The request was successful.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "The blueprint execution failed.",
+                            "style": "error",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        try:
+            blueprint_key = self._get_field("blueprintKey")
+            payload = self._get_field("payload")
+            expanded_execution_environment = self.execution_environment | {"payload": payload}
+            return_value = self.runner.run_blueprint_by_key(
+                blueprint_key, expanded_execution_environment
+            )
+            self.result = return_value
+            self.outcome = "success"
+        except BaseException as e:
+            self.outcome = "error"
+            raise e

writer/blocks/setstate.py

@@ -1,53 +1,63 @@
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate
 
 
-class SetState(WorkflowBlock):
-
+class SetState(BlueprintBlock):
     @classmethod
     def register(cls, type: str):
         super(SetState, cls).register(type)
-        register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
-            writer={
-                "name": "Set state",
-                "description": "Set the value for a state element.",
-                "category": "Other",
-                "fields": {
-                    "element": {
-                        "name": "State element",
-                        "type": "Text"
-                    },
-                    "value": {
-                        "name": "Value",
-                        "type": "Text",
-                        "control": "Textarea"
-                    },
-                },
-                "outs": {
-                    "success": {
-                        "name": "Success",
-                        "description": "If the function doesn't raise an Exception.",
-                        "style": "success",
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Set state",
+                    "description": "Stores a value in the Agent's state. Use to remember data across steps.",
+                    "category": "Other",
+                    "fields": {
+                        "element": {
+                            "name": "Link Variable",
+                            "type": "Binding",
+                            "desc": "Set the variable here and use it across your agent.",
+                        },
+                        "valueType": {
+                            "name": "Value type",
+                            "type": "Text",
+                            "description": "Specify whether to interpret the value as plain text or JSON.",
+                            "options": {
+                                "text": "Plain text",
+                                "JSON": "JSON",
+                            },
+                            "default": "text",
+                        },
+                        "value": {"name": "Value", "type": "Text", "control": "Textarea"},
                     },
-                    "error": {
-                        "name": "Error",
-                        "description": "If the function raises an Exception.",
-                        "style": "error",
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The state was updated successfully.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "There was an error updating the state.",
+                            "style": "error",
+                        },
                     },
                 },
-            }
-        ))
+            ),
+        )
 
     def run(self):
         try:
             element = self._get_field("element", required=True)
-            value = self._get_field("value")
+            value_type = self._get_field("valueType")
+            value = self._get_field("value", as_json=value_type == "JSON")
 
             self._set_state(element, value)
             self.result = value
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e

writer/blocks/sharedblueprint.py

@@ -0,0 +1,86 @@
+"""
+Shared blueprint implementation for user-created reusable blueprints.
+
+Shared blueprints execute stored blueprint components by loading them from the component tree.
+The component's content.sourceBlueprintId field references the source blueprint.
+"""
+
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import BlueprintBlock
+from writer.ss_types import AbstractTemplate
+
+
+class SharedBlueprint(BlueprintBlock):
+    """
+    Shared blueprint that executes components from a source blueprint in the component tree.
+
+    The source blueprint is identified by the sourceBlueprintId content field.
+    """
+
+    @classmethod
+    def register(cls, type: str):
+        """Register the blueprints_shared type with its abstract template."""
+        super(SharedBlueprint, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Shared Blueprint",
+                    "description": "Executes a shared blueprint from the component tree.",
+                    "category": "Logic",
+                    "toolkit": "blueprints",
+                    "featureFlags": ["shared_blueprints"],
+                    "fields": {
+                        "payload": {
+                            "name": "Payload",
+                            "desc": "The value specified will be available using the template syntax, e.g. @{payload}.",
+                            "default": "{}",
+                            "type": "Text",
+                            "control": "Textarea",
+                        },
+                    },
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "Blueprint executed successfully.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "Blueprint execution failed.",
+                            "style": "error",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        """Execute the source blueprint's components."""
+        source_blueprint_id = self.component.content.get("sourceBlueprintId", "")
+
+        if not source_blueprint_id:
+            raise ValueError("No source blueprint ID specified")
+
+        try:
+            payload = self._get_field("payload")
+            expanded_execution_environment = self.execution_environment | {"payload": payload}
+
+            # Get blueprint name for title (matching run_blueprint_by_key pattern)
+            source_blueprint = self.runner.session.session_component_tree.get_component(
+                source_blueprint_id
+            )
+            blueprint_name = source_blueprint.content.get("key", "Shared Blueprint") if source_blueprint else "Shared Blueprint"
+
+            return_value = self.runner.run_blueprint(
+                source_blueprint_id,
+                expanded_execution_environment,
+                title=f"Shared blueprint execution ({blueprint_name})"
+            )
+
+            self.result = return_value
+            self.outcome = "success"
+        except BaseException as e:
+            self.outcome = "error"
+            raise e

writer/blocks/uieventtrigger.py

@@ -0,0 +1,49 @@
+from writer.abstract import register_abstract_template
+from writer.blocks.base_trigger import BlueprintTrigger
+from writer.ss_types import AbstractTemplate
+
+
+class UIEventTrigger(BlueprintTrigger):
+    @classmethod
+    def register(cls, type: str):
+        super(UIEventTrigger, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "UI Trigger",
+                    "description": "Triggers an event based on UI interactions like button clicks or input changes.",
+                    "category": "Triggers",
+                    "fields": {
+                        "refComponentId": {
+                            "name": "Component Id",
+                            "type": "Component Id",
+                            "options": "uiComponentsWithEvents",
+                            "desc": "The id of the component that will trigger this branch.",
+                        },
+                        "refEventType": {
+                            "name": "Event type",
+                            "type": "Component Event Type",
+                            "desc": "The type of the event that will trigger this branch. For example, wf-click.",
+                            "options": "eventTypes",
+                        },
+                        "defaultResult": {
+                            "name": "Default result",
+                            "type": "Code",
+                            "desc": 'The result that is used when the blueprint is triggered from the "Run blueprint" button',
+                        },
+                    },
+                    "outs": {
+                        "trigger": {
+                            "name": "Trigger",
+                            "style": "success",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        super().run()
+        self.outcome = "trigger"

writer/blocks/writeraddchatmessage.py

@@ -1,34 +1,72 @@
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 
-class WriterAddChatMessage(WorkflowBlock):
+class WriterAddChatMessage(BlueprintBlock):
 
     @classmethod
     def register(cls, type: str):
         super(WriterAddChatMessage, cls).register(type)
         register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
+            baseType="blueprints_node",
             writer={
                 "name": "Add chat message",
-                "description": "Add a message to a conversation.",
+                "description": "Adds a message to the conversation history. Use for displaying user or AI messages.",
                 "category": "Writer",
+                "deprecated": True,
                 "fields": {
                     "conversationStateElement": {
                         "name": "Conversation state element",
-                        "desc": "Where the conversation is stored",
-                        "type": "Text",
+                        "desc": "The variable that has your conversation object.",
+                        "type": "Binding",
                     },
                     "message": {
                         "name": "Message",
                         "type": "Object",
                         "init": '{ "role": "assistant", "content": "Hello" }',
+                        "desc": "A message object. Content can be text string or array of objects for multimodal (text + images) with X5 model.",
                         "validator": {
                             "type": "object",
                             "properties": {
-                                "role": { "type": "string" },
-                                "content": { "type": "string" },
+                                "role": {"type": "string"},
+                                "content": {
+                                    "oneOf": [
+                                        {"type": "string"},
+                                        {
+                                            "type": "array",
+                                            "items": {
+                                                "oneOf": [
+                                                    {
+                                                        "type": "object",
+                                                        "properties": {
+                                                            "type": {"type": "string", "enum": ["text"]},
+                                                            "text": {"type": "string"}
+                                                        },
+                                                        "required": ["type", "text"],
+                                                        "additionalProperties": False
+                                                    },
+                                                    {
+                                                        "type": "object",
+                                                        "properties": {
+                                                            "type": {"type": "string", "enum": ["image_url"]},
+                                                            "image_url": {
+                                                                "type": "object",
+                                                                "properties": {
+                                                                    "url": {"type": "string"}
+                                                                },
+                                                                "required": ["url"],
+                                                                "additionalProperties": False
+                                                            }
+                                                        },
+                                                        "required": ["type", "image_url"],
+                                                        "additionalProperties": False
+                                                    }
+                                                ]
+                                            }
+                                        }
+                                    ]
+                                },
                             },
                             "additionalProperties": False,
                         }
@@ -37,12 +75,12 @@ class WriterAddChatMessage(WorkflowBlock):
                 "outs": {
                     "success": {
                         "name": "Success",
-                        "description": "If the function doesn't raise an Exception.",
+                        "description": "The message was added to the conversation.",
                         "style": "success",
                     },
                     "error": {
                         "name": "Error",
-                        "description": "If the function raises an Exception.",
+                        "description": "There was an error adding the message.",
                         "style": "error",
                     },
                 },
@@ -59,7 +97,7 @@ class WriterAddChatMessage(WorkflowBlock):
             conversation = self.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
 
             if conversation is None or not isinstance(conversation, writer.ai.Conversation):
-                raise WriterConfigurationError("The state element specified doesn't contain a conversation. Initialize one using the block 'Initialize chat'.")
+                raise WriterConfigurationError("The state element specified doesn't contain a conversation. Initialize one using the block 'Start chat conversation'.")
             
             writer.ai.Conversation.validate_message(message)
             conversation += message
@@ -71,4 +109,4 @@ class WriterAddChatMessage(WorkflowBlock):
             self.outcome = "error"
             raise e
 
-    
+    

writer/blocks/writeraddtokg.py

@@ -1,25 +1,25 @@
 from typing import Any
 
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import WriterBlock
 from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 
-class WriterAddToKG(WorkflowBlock):
+class WriterAddToKG(WriterBlock):
 
     @classmethod
     def register(cls, type: str):
         super(WriterAddToKG, cls).register(type)
         register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
+            baseType="blueprints_node",
             writer={
                 "name": "Add to Knowledge Graph",
-                "description": "Adds files to an existing knowledge graph.",
+                "description": "Adds structured information to the knowledge graph. Use for storing facts AI can reference.",
                 "category": "Writer",
                 "fields": {
                     "graphId": {
-                        "name": "Graph id",
-                        "type": "Text",
+                        "name": "Graph Id",
+                        "type": "Graph Id",
                         "desc": "The id for an existing knowledge graph. It has a UUID format.",
                         "validator": {
                             "type": "string",
@@ -30,21 +30,34 @@ class WriterAddToKG(WorkflowBlock):
                         "name": "Files",
                         "type": "Object",
                         "default": "[]",
-                        "desc": "A list of files to be uploaded and added to the knowledge graph. You can use files uploaded via the File Input component or specify dictionaries with data, type and name.",
+                        "desc": "A list of files to be uploaded and added to the knowledge graph. You can use files uploaded via the File input component or specify dictionaries with data, type and name.",
                         "validator": {
                             "type": "array",
                         }
                     },
+                    "urls": {
+                        "name": "URLs",
+                        "type": "Object",
+                        "default": "[]",
+                        "desc": "A list of URLs to be added to the knowledge graph. Web content from these URLs will be indexed.",
+                        "validator": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "format": "uri",
+                            }
+                        }
+                    },
                 },
                 "outs": {
                     "success": {
                         "name": "Success",
-                        "description": "If the execution was successful.",
+                        "description": "Content was added to the knowledge graph.",
                         "style": "success",
                     },
                     "error": {
                         "name": "Error",
-                        "description": "If the function raises an Exception.",
+                        "description": "There was an error adding content to the knowledge graph.",
                         "style": "error",
                     },
                 },
@@ -65,24 +78,38 @@ class WriterAddToKG(WorkflowBlock):
             import writer.ai
 
             graph_id = self._get_field("graphId", required=True)
-            raw_files = self._get_field("files", as_json=True)
+            raw_files = self._get_field("files", as_json=True, default_field_value="[]")
+            urls = self._get_field("urls", as_json=True, default_field_value="[]")
             prepared_files = []
 
             if not isinstance(raw_files, list):
                 raise WriterConfigurationError("Files must be a list.")
+            
+            if not isinstance(urls, list):
+                raise WriterConfigurationError("URLs must be a list.")
+            
+            if not raw_files and not urls:
+                raise WriterConfigurationError("At least one file or URL must be provided.")
 
             for raw_file in raw_files:
                 prepared_files.append(self._get_prepared_file(raw_file))
                 
             graph = writer.ai.retrieve_graph(graph_id)
             
+            # Add files to the graph
             for prepared_file in prepared_files:
                 file = writer.ai.upload_file(prepared_file.get("data"),
                                              prepared_file.get("type"),
                                              prepared_file.get("name"))
                 graph.add_file(file)
+            
+            # Add URLs to the graph using SDK 2.3.0 feature
+            for url in urls:
+                if not isinstance(url, str):
+                    raise WriterConfigurationError(f"URL must be a string, got {type(url)}")
+                graph.add_url(url)
 
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e