Merge branch 'dev' into ntindle/open-2097-integration-test-complete-t…

…he-tutorial

.github/workflows/platform-frontend-ci.yml

@@ -23,6 +23,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
@@ -38,24 +39,12 @@ jobs:
 
   test:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        browser: [chromium, firefox, webkit]
 
     steps:
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: false
-
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: false
-          dotnet: false
-          haskell: false
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -66,6 +55,12 @@ jobs:
         with:
           node-version: "21"
 
+      - name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@main
+        with:
+          large-packages: false  # slow
+          docker-images: false  # limited benefit
+
       - name: Copy default supabase .env
         run: |
           cp ../supabase/docker/.env.example ../.env
@@ -86,16 +81,16 @@ jobs:
         run: |
           cp .env.example .env
 
-      - name: Install Playwright Browsers
-        run: yarn playwright install --with-deps
+      - name: Install Browser '${{ matrix.browser }}'
+        run: yarn playwright install --with-deps ${{ matrix.browser }}
 
       - name: Run tests
         run: |
-          yarn test
+          yarn test --project=${{ matrix.browser }}
 
       - uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
-          name: playwright-report
+          name: playwright-report-${{ matrix.browser }}
           path: playwright-report/
           retention-days: 30

autogpt_platform/backend/backend/blocks/basic.py

@@ -492,3 +492,101 @@ def __init__(self):
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "output", input_data.text
+
+
+class CreateDictionaryBlock(Block):
+    class Input(BlockSchema):
+        values: dict[str, Any] = SchemaField(
+            description="Key-value pairs to create the dictionary with",
+            placeholder="e.g., {'name': 'Alice', 'age': 25}",
+        )
+
+    class Output(BlockSchema):
+        dictionary: dict[str, Any] = SchemaField(
+            description="The created dictionary containing the specified key-value pairs"
+        )
+        error: str = SchemaField(
+            description="Error message if dictionary creation failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="b924ddf4-de4f-4b56-9a85-358930dcbc91",
+            description="Creates a dictionary with the specified key-value pairs. Use this when you know all the values you want to add upfront.",
+            categories={BlockCategory.DATA},
+            input_schema=CreateDictionaryBlock.Input,
+            output_schema=CreateDictionaryBlock.Output,
+            test_input=[
+                {
+                    "values": {"name": "Alice", "age": 25, "city": "New York"},
+                },
+                {
+                    "values": {"numbers": [1, 2, 3], "active": True, "score": 95.5},
+                },
+            ],
+            test_output=[
+                (
+                    "dictionary",
+                    {"name": "Alice", "age": 25, "city": "New York"},
+                ),
+                (
+                    "dictionary",
+                    {"numbers": [1, 2, 3], "active": True, "score": 95.5},
+                ),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # The values are already validated by Pydantic schema
+            yield "dictionary", input_data.values
+        except Exception as e:
+            yield "error", f"Failed to create dictionary: {str(e)}"
+
+
+class CreateListBlock(Block):
+    class Input(BlockSchema):
+        values: List[Any] = SchemaField(
+            description="A list of values to be combined into a new list.",
+            placeholder="e.g., ['Alice', 25, True]",
+        )
+
+    class Output(BlockSchema):
+        list: List[Any] = SchemaField(
+            description="The created list containing the specified values."
+        )
+        error: str = SchemaField(description="Error message if list creation failed.")
+
+    def __init__(self):
+        super().__init__(
+            id="a912d5c7-6e00-4542-b2a9-8034136930e4",
+            description="Creates a list with the specified values. Use this when you know all the values you want to add upfront.",
+            categories={BlockCategory.DATA},
+            input_schema=CreateListBlock.Input,
+            output_schema=CreateListBlock.Output,
+            test_input=[
+                {
+                    "values": ["Alice", 25, True],
+                },
+                {
+                    "values": [1, 2, 3, "four", {"key": "value"}],
+                },
+            ],
+            test_output=[
+                (
+                    "list",
+                    ["Alice", 25, True],
+                ),
+                (
+                    "list",
+                    [1, 2, 3, "four", {"key": "value"}],
+                ),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # The values are already validated by Pydantic schema
+            yield "list", input_data.values
+        except Exception as e:
+            yield "error", f"Failed to create list: {str(e)}"

autogpt_platform/backend/backend/blocks/code_extraction_block.py

@@ -0,0 +1,110 @@
+import re
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class CodeExtractionBlock(Block):
+    class Input(BlockSchema):
+        text: str = SchemaField(
+            description="Text containing code blocks to extract (e.g., AI response)",
+            placeholder="Enter text containing code blocks",
+        )
+
+    class Output(BlockSchema):
+        html: str = SchemaField(description="Extracted HTML code")
+        css: str = SchemaField(description="Extracted CSS code")
+        javascript: str = SchemaField(description="Extracted JavaScript code")
+        python: str = SchemaField(description="Extracted Python code")
+        sql: str = SchemaField(description="Extracted SQL code")
+        java: str = SchemaField(description="Extracted Java code")
+        cpp: str = SchemaField(description="Extracted C++ code")
+        csharp: str = SchemaField(description="Extracted C# code")
+        json_code: str = SchemaField(description="Extracted JSON code")
+        bash: str = SchemaField(description="Extracted Bash code")
+        php: str = SchemaField(description="Extracted PHP code")
+        ruby: str = SchemaField(description="Extracted Ruby code")
+        yaml: str = SchemaField(description="Extracted YAML code")
+        markdown: str = SchemaField(description="Extracted Markdown code")
+        typescript: str = SchemaField(description="Extracted TypeScript code")
+        xml: str = SchemaField(description="Extracted XML code")
+        remaining_text: str = SchemaField(
+            description="Remaining text after code extraction"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="d3a7d896-3b78-4f44-8b4b-48fbf4f0bcd8",
+            description="Extracts code blocks from text and identifies their programming languages",
+            categories={BlockCategory.TEXT},
+            input_schema=CodeExtractionBlock.Input,
+            output_schema=CodeExtractionBlock.Output,
+            test_input={
+                "text": "Here's a Python example:\n```python\nprint('Hello World')\n```\nAnd some HTML:\n```html\n<h1>Title</h1>\n```"
+            },
+            test_output=[
+                ("html", "<h1>Title</h1>"),
+                ("python", "print('Hello World')"),
+                ("remaining_text", "Here's a Python example:\nAnd some HTML:"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        # List of supported programming languages with mapped aliases
+        language_aliases = {
+            "html": ["html", "htm"],
+            "css": ["css"],
+            "javascript": ["javascript", "js"],
+            "python": ["python", "py"],
+            "sql": ["sql"],
+            "java": ["java"],
+            "cpp": ["cpp", "c++"],
+            "csharp": ["csharp", "c#", "cs"],
+            "json_code": ["json"],
+            "bash": ["bash", "shell", "sh"],
+            "php": ["php"],
+            "ruby": ["ruby", "rb"],
+            "yaml": ["yaml", "yml"],
+            "markdown": ["markdown", "md"],
+            "typescript": ["typescript", "ts"],
+            "xml": ["xml"],
+        }
+
+        # Extract code for each language
+        for canonical_name, aliases in language_aliases.items():
+            code = ""
+            # Try each alias for the language
+            for alias in aliases:
+                code_for_alias = self.extract_code(input_data.text, alias)
+                if code_for_alias:
+                    code = code + "\n\n" + code_for_alias if code else code_for_alias
+
+            if code:  # Only yield if there's actual code content
+                yield canonical_name, code
+
+        # Remove all code blocks from the text to get remaining text
+        pattern = (
+            r"```(?:"
+            + "|".join(
+                re.escape(alias)
+                for aliases in language_aliases.values()
+                for alias in aliases
+            )
+            + r")\s+[\s\S]*?```"
+        )
+
+        remaining_text = re.sub(pattern, "", input_data.text).strip()
+        remaining_text = re.sub(r"\n\s*\n", "\n", remaining_text)
+
+        if remaining_text:  # Only yield if there's remaining text
+            yield "remaining_text", remaining_text
+
+    def extract_code(self, text: str, language: str) -> str:
+        # Escape special regex characters in the language string
+        language = re.escape(language)
+        # Extract all code blocks enclosed in ```language``` blocks
+        pattern = re.compile(rf"```{language}\s+(.*?)```", re.DOTALL | re.IGNORECASE)
+        matches = pattern.finditer(text)
+        # Combine all code blocks for this language with newlines between them
+        code_blocks = [match.group(1).strip() for match in matches]
+        return "\n\n".join(code_blocks) if code_blocks else ""