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

writer/blocks/writerfileapi.py

@@ -0,0 +1,85 @@
+from uuid import uuid4
+
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import WriterBlock
+from writer.ss_types import AbstractTemplate
+
+
+class WriterUploadFile(WriterBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(WriterUploadFile, cls).register(type)
+        register_abstract_template(type, AbstractTemplate(
+            baseType="blueprints_node",
+            writer={
+                "name": "Add files to Writer cloud",
+                "description": "Uploads files to the Writer platform.",
+                "category": "Writer",
+                "fields": {
+                    "files": {
+                        "name": "Files",
+                        "type": "Object",
+                        "default": "[]",
+                        "desc": "A list of files to be uploaded to the Writer platform. You can use files uploaded via the File input component or specify dictionaries with data, type and name.",
+                        "validator": {
+                            "type": "array"
+                        }
+                    },
+                },
+                "outs": {
+                    "success": {
+                        "name": "Success",
+                        "description": "File successfully uploaded.",
+                        "style": "success"
+                    },
+                    "error": {
+                        "name": "Error",
+                        "description": "There was an error uploading the files.",
+                        "style": "error"
+                    }
+                }
+            }
+        ))
+
+    def run(self):
+        from writer.ai import WriterAIManager
+        try:
+            files = self._get_field("files", as_json=True, required=True)
+            outputs = []
+            if not isinstance(files, list):
+                raise ValueError("Files must be a list.")
+            for file in files:
+                if not isinstance(file, dict):
+                    raise ValueError("Files must be dictionaries and contain `data`, `type` and `name` attributes.")
+                if "data" not in file or "type" not in file:
+                    raise ValueError("A file specified as a dictionary must contain `data` and `type` attributes.")
+
+                data = file.get("data")
+                file_type = file.get("type")
+                name = file.get("name")
+                file_name = name or f"agent-builder-{file_type}-{uuid4()}"
+                content_disposition = f'attachment; filename="{file_name}"'
+
+                client = WriterAIManager.acquire_client()
+
+                file = client.files.upload(
+                    content=data,
+                    content_type=file_type,
+                    content_disposition=content_disposition
+                    )
+
+                outputs.append({
+                    "id": file.id,
+                    "name": file.name,
+                    "status": file.status,
+                    "created_at": file.created_at.isoformat(),
+                    "graph_ids": file.graph_ids
+                })
+            if len(outputs) == 0:
+                raise ValueError("No files were uploaded.")
+            self.result = outputs
+            self.outcome = "success"
+        except BaseException as e:
+            self.outcome = "error"
+            raise e

writer/blocks/writerinitchat.py

@@ -1,21 +1,22 @@
 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
 
-DEFAULT_MODEL = "palmyra-x-004"
+DEFAULT_MODEL = "palmyra-x5"
 
 
-class WriterInitChat(WorkflowBlock):
+class WriterInitChat(WriterBlock):
 
     @classmethod
     def register(cls, type: str):
         super(WriterInitChat, cls).register(type)
         register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
+            baseType="blueprints_node",
             writer={
-                "name": "Initialize chat",
-                "description": "If it doesn't already exist, initializes a conversation for Chat completion",
+                "name": "Start chat conversation",
+                "description": "Starts a new chat conversation. Use to initialize context for AI interactions.",
                 "category": "Writer",
+                "deprecated": True,
                 "fields": {
                     "conversationStateElement": {
                         "name": "Conversation state element",
@@ -23,8 +24,8 @@ class WriterInitChat(WorkflowBlock):
                         "type": "Text",
                     },
                     "modelId": {
-                        "name": "Model id",
-                        "type": "Text",
+                        "name": "Model",
+                        "type": "Model Id",
                         "default": DEFAULT_MODEL
                     },
                     "temperature": {
@@ -36,17 +37,27 @@ class WriterInitChat(WorkflowBlock):
                             "minimum": 0,
                             "maximum": 1,
                         }
+                    },
+                    "max_tokens": {
+                        "name": "Max output tokens",
+                        "type": "Number",
+                        "default": "1024",
+                        "validator": {
+                            "type": "number",
+                            "minimum": 1,
+                            "maximum": 16384,
+                        }
                     }
                 },
                 "outs": {
                     "success": {
                         "name": "Success",
-                        "description": "If the function doesn't raise an Exception.",
+                        "description": "The conversation was initialized.",
                         "style": "success",
                     },
                     "error": {
                         "name": "Error",
-                        "description": "If the function raises an Exception.",
+                        "description": "There was an error initializing the conversation.",
                         "style": "error",
                     },
                 },
@@ -60,7 +71,8 @@ class WriterInitChat(WorkflowBlock):
             conversation_state_element = self._get_field("conversationStateElement")
             temperature = float(self._get_field("temperature", False, "0.7"))
             model_id = self._get_field("modelId", False, default_field_value=DEFAULT_MODEL)
-            config = { "temperature": temperature, "model": model_id}
+            max_tokens = int(self._get_field("max_tokens", False, "1024"))
+            config = { "temperature": temperature, "model": model_id, "max_tokens": max_tokens }
 
             conversation = self.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
 
@@ -79,4 +91,4 @@ class WriterInitChat(WorkflowBlock):
             self.outcome = "error"
             raise e
 
-    
+    

writer/blocks/writerkeyvaluestorage.py

@@ -0,0 +1,106 @@
+import re
+
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import WriterBlock
+from writer.ss_types import AbstractTemplate, WriterConfigurationError
+
+ALLOWED_CHARS = re.compile(r'^[A-Za-z0-9\-_]+$')
+
+class WriterKeyValueStorage(WriterBlock):
+    @classmethod
+    def register(cls, type: str):
+        super(WriterKeyValueStorage, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Key-Value Storage",
+                    "description": "Stores data between sessions. Uses unique keys (names) to identify the data. Keys can only contain alphanumeric characters, underscores, and hyphens.",
+                    "category": "Writer",
+                    "fields": {
+                        "action": {
+                            "name": "Action",
+                            "type": "Text",
+                            "description": "What action to perform on the data (save, get, delete, list all keys).",
+                            "options": {
+                                "Save": "Save",
+                                "Get": "Get",
+                                "Delete": "Delete",
+                                "List keys": "List keys",
+                            },
+                            "default": "Save",
+                        },
+                        "key": {
+                            "name": "Key",
+                            "type": "Text",
+                            "description": "Unique identifier of your data that will be used to retrieve, update and delete it.",
+                        },
+                        "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",
+                            "description": "Data that you want to store.",
+                            "control": "Textarea",
+                        },
+                    },
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The request was successful.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "The request wasn't successful.",
+                            "style": "error",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        try:
+            self.result = self._execute_action()
+            self.outcome = "success"
+        except BaseException as e:
+            self.outcome = "error"
+            raise e
+
+    def _execute_action(self):
+        from writer.journal import JOURNAL_KEY_PREFIX
+        from writer.keyvalue_storage import KeyValueStorage
+
+        action = self._get_field("action", default_field_value="Save")
+
+        with self.acquire_httpx_client() as client:
+            writer_kv_storage = KeyValueStorage(client=client)
+
+            if action == "List keys":
+                response = writer_kv_storage.get_data_keys()
+                return [key for key in response if not key.startswith(JOURNAL_KEY_PREFIX)]
+
+            key = self._get_field("key", required=True)
+            if not ALLOWED_CHARS.fullmatch(key):
+                raise WriterConfigurationError("Key can only contain alphanumeric characters, underscores and hyphens")
+
+            if action == "Save":
+                value_type = self._get_field("valueType")
+                value = self._get_field("value", as_json=value_type == "JSON")
+                return writer_kv_storage.save(key, value)
+            if action == "Get":
+                return writer_kv_storage.get(key, type_="data")["data"]
+            if action == "Delete":
+                return writer_kv_storage.delete(key)
+
+            raise WriterConfigurationError(f"Unknown action for the Key-Value Storage: {action}")

writer/blocks/writernocodeapp.py

@@ -1,49 +1,47 @@
 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
 
 
-class WriterNoCodeApp(WorkflowBlock):
-
+class WriterNoCodeApp(WriterBlock):
     @classmethod
     def register(cls, type: str):
         super(WriterNoCodeApp, cls).register(type)
-        register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
-            writer={
-                "name": "No-code app",
-                "description": "Run a no-code app.",
-                "category": "Writer",
-                "fields": {
-                    "appId": {
-                        "name": "App Id",
-                        "type": "Text",
-                        "desc": "The app id can be found in the app's URL. It has a UUID format.",
-                        "validator": {
-                            "type": "string",
-                            "format": "uuid",
-                        }
-                    },
-                    "appInputs": {
-                        "name": "App inputs",
-                        "type": "Key-Value",
-                        "default": "{}"
-                    },
-                },
-                "outs": {
-                    "success": {
-                        "name": "Success",
-                        "description": "If the execution was successful.",
-                        "style": "success",
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "AI Studio agent",
+                    "description": "Runs a Writer AI Studio agent app by ID.",
+                    "category": "Writer",
+                    "fields": {
+                        "appId": {
+                            "name": "App Id",
+                            "type": "App Id",
+                            "desc": "The agent id can be found in the agent's URL. It has a UUID format.",
+                            "validator": {
+                                "type": "string",
+                                "format": "uuid",
+                            },
+                        },
+                        "appInputs": {"name": "App inputs", "type": "Key-Value", "default": "{}"},
                     },
-                    "error": {
-                        "name": "Error",
-                        "description": "If the function raises an Exception.",
-                        "style": "error",
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The agent ran successfully.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "There was an error running the agent.",
+                            "style": "error",
+                        },
                     },
                 },
-            }
-        ))
+            ),
+        )
 
     def run(self):
         try:
@@ -61,4 +59,4 @@ class WriterNoCodeApp(WorkflowBlock):
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e

writer/blocks/writerparsepdf.py

@@ -0,0 +1,73 @@
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import WriterBlock
+from writer.ss_types import AbstractTemplate
+
+
+class WriterParsePDFByFileID(WriterBlock):
+    @classmethod
+    def register(cls, type: str):
+        super(WriterParsePDFByFileID, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Parse PDF tool",
+                    "description": "Uses Writer API to extract the text content of a PDF file stored in Writer cloud.",
+                    "category": "Writer",
+                    "fields": {
+                        "file": {
+                                "name": "File",
+                                "type": "Text",
+                                "default": "",
+                                "desc": "UUID of a file object in Files API.",
+                                "validator": {
+                                    "type": "string",
+                                    "format": "uuid"
+                                }
+                        },
+                        "markdown": {
+                            "name": "Enable markdown",
+                            "type": "Boolean",
+                            "default": "yes",
+                            "validator": {
+                                "type": "boolean",
+                            },
+                        }
+                    },
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The PDF was parsed successfully.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "There was an error parsing the PDF.",
+                            "style": "error",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        try:
+            import writer.ai
+
+            file_uuid = self._get_field("file")
+            markdown_input = self._get_field("markdown", False, "yes") == "yes"
+
+            client = writer.ai.WriterAIManager.acquire_client()
+
+            response = client.tools.parse_pdf(
+                file_uuid,
+                format="markdown" if markdown_input else "text"
+            )
+
+            self.result = response.content
+            self.outcome = "success"
+
+        except BaseException as e:
+            self.outcome = "error"
+            raise e

writer/blocks/writerstructuredoutput.py

@@ -0,0 +1,105 @@
+import json
+
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import WriterBlock
+from writer.ss_types import AbstractTemplate
+
+DEFAULT_MODEL = "palmyra-x5"
+
+
+class WriterStructuredOutput(WriterBlock):
+    @classmethod
+    def register(cls, type: str):
+        super(WriterStructuredOutput, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Structured output",
+                    "description": "Defines a JSON response format that the agent will use to structure its output.",
+                    "category": "Writer",
+                    "fields": {
+                        "prompt": {"name": "Prompt", "type": "Text", "control": "Textarea", "desc": "Description of a JSON object to be created."},
+                        "modelId": {
+                            "name": "Model",
+                            "type": "Model Id",
+                            "default": DEFAULT_MODEL
+                        },
+                        "jsonSchema": {
+                            "name": "JSON Schema",
+                            "desc": "JSON schema that defines the structure of the response. For example, `{\"type\": \"object\", \"properties\": {...}, \"required\": [...]}`.",
+                            "type": "JSON",
+                            "default": "{}"
+                        },
+                        "max_tokens": {
+                            "name": "Max output tokens",
+                            "type": "Number",
+                            "default": "1024",
+                            "validator": {
+                                "type": "number",
+                                "minimum": 1,
+                                "maximum": 16384,
+                            }
+                        }
+                    },
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The structured output was generated.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "There was an error generating the output.",
+                            "style": "error",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        import writer.ai
+
+        try:
+            prompt = self._get_field("prompt")
+            model_id = self._get_field("modelId", False, default_field_value=DEFAULT_MODEL)
+            conversation = writer.ai.Conversation()
+            schema = self._get_field("jsonSchema", True, default_field_value="{}")
+            max_tokens = int(self._get_field("max_tokens", False, "1024"))
+
+            response_format = {
+                "type": "json_schema",
+                "json_schema": {
+                    "schema": schema
+                    }
+                }
+
+            conversation += {
+                "role": "user",
+                "content": prompt,
+            }
+            config = { "model": model_id, "max_tokens": max_tokens }
+            msg = conversation.complete(response_format=response_format, config=config)
+            conversation += msg
+
+            raw_content = msg.get("content")
+            if not raw_content:
+                self.outcome = "error"
+                raise RuntimeError("No content returned from the model. Please validate the prompt and model configuration.")
+
+            try:
+                # Attempt to parse the raw content as JSON
+                content = json.loads(raw_content)
+            except json.JSONDecodeError:
+                self.outcome = "error"
+                raise RuntimeError(
+                    f"Failed to decode JSON content. The raw content was: {raw_content}. Please validate the prompt and model configuration."
+                )
+
+            self.result = content
+            self.outcome = "success"
+        except BaseException as e:
+            self.outcome = "error"
+            raise e