Merge branch 'dev' into update-font-fix

.github/workflows/repo-close-stale-issues.yml

@@ -25,7 +25,7 @@ jobs:
           close-issue-message: >
             This issue was closed automatically because it has been stale for 10 days
             with no activity.
-          days-before-stale: 50
+          days-before-stale: 100
           days-before-close: 10
           # Do not touch meta issues:
           exempt-issue-labels: meta,fridge,project management

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -18,7 +18,7 @@
 SIMPLE_LOG_FORMAT = "%(asctime)s %(levelname)s  %(title)s%(message)s"
 
 DEBUG_LOG_FORMAT = (
-    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d" "  %(title)s%(message)s"
+    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d  %(title)s%(message)s"
 )
 
 

autogpt_platform/autogpt_libs/pyproject.toml

@@ -10,18 +10,18 @@ packages = [{ include = "autogpt_libs" }]
 colorama = "^0.4.6"
 expiringdict = "^1.2.2"
 google-cloud-logging = "^3.11.3"
-pydantic = "^2.10.3"
-pydantic-settings = "^2.7.0"
+pydantic = "^2.10.5"
+pydantic-settings = "^2.7.1"
 pyjwt = "^2.10.1"
-pytest-asyncio = "^0.25.0"
+pytest-asyncio = "^0.25.2"
 pytest-mock = "^3.14.0"
 python = ">=3.10,<4.0"
 python-dotenv = "^1.0.1"
-supabase = "^2.10.0"
+supabase = "^2.11.0"
 
 [tool.poetry.group.dev.dependencies]
 redis = "^5.2.1"
-ruff = "^0.8.6"
+ruff = "^0.9.2"
 
 [build-system]
 requires = ["poetry-core"]

autogpt_platform/backend/.env.example

@@ -15,6 +15,9 @@ REDIS_PORT=6379
 REDIS_PASSWORD=password
 
 ENABLE_CREDIT=false
+STRIPE_API_KEY=
+STRIPE_WEBHOOK_SECRET=
+
 # What environment things should be logged under: local dev or prod
 APP_ENV=local
 # What environment to behave as: "local" or "cloud"
@@ -36,7 +39,7 @@ SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
 ## to use the platform's webhook-related functionality.
 ## If you are developing locally, you can use something like ngrok to get a publc URL
 ## and tunnel it to your locally running backend.
-PLATFORM_BASE_URL=https://your-public-url-here
+PLATFORM_BASE_URL=http://localhost:3000
 
 ## == INTEGRATION CREDENTIALS == ##
 # Each set of server side credentials is required for the corresponding 3rd party
@@ -72,6 +75,12 @@ GOOGLE_CLIENT_SECRET=
 TWITTER_CLIENT_ID=
 TWITTER_CLIENT_SECRET=
 
+# Linear App
+# Make a new workspace for your OAuth APP -- trust me
+# https://linear.app/settings/api/applications/new
+# Callback URL: http://localhost:3000/auth/integrations/oauth_callback
+LINEAR_CLIENT_ID=
+LINEAR_CLIENT_SECRET=
 
 ## ===== OPTIONAL API KEYS ===== ##
 
@@ -82,10 +91,12 @@ GROQ_API_KEY=
 OPEN_ROUTER_API_KEY=
 
 # Reddit
+# Go to https://www.reddit.com/prefs/apps and create a new app
+# Choose "script" for the type
+# Fill in the redirect uri as <your_frontend_url>/auth/integrations/oauth_callback, e.g. http://localhost:3000/auth/integrations/oauth_callback
 REDDIT_CLIENT_ID=
 REDDIT_CLIENT_SECRET=
-REDDIT_USERNAME=
-REDDIT_PASSWORD=
+REDDIT_USER_AGENT="AutoGPT:1.0 (by /u/autogpt)"
 
 # Discord
 DISCORD_BOT_TOKEN=
@@ -130,6 +141,9 @@ EXA_API_KEY=
 # E2B
 E2B_API_KEY=
 
+# Mem0
+MEM0_API_KEY=
+
 # Nvidia
 NVIDIA_API_KEY=
 

autogpt_platform/backend/backend/blocks/basic.py

@@ -1,13 +1,52 @@
+import enum
 from typing import Any, List
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
 from backend.data.model import SchemaField
+from backend.util.file import MediaFile, store_media_file
 from backend.util.mock import MockObject
 from backend.util.text import TextFormatter
+from backend.util.type import convert
 
 formatter = TextFormatter()
 
 
+class FileStoreBlock(Block):
+    class Input(BlockSchema):
+        file_in: MediaFile = SchemaField(
+            description="The file to store in the temporary directory, it can be a URL, data URI, or local path."
+        )
+
+    class Output(BlockSchema):
+        file_out: MediaFile = SchemaField(
+            description="The relative path to the stored file in the temporary directory."
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="cbb50872-625b-42f0-8203-a2ae78242d8a",
+            description="Stores the input file in the temporary directory.",
+            categories={BlockCategory.BASIC, BlockCategory.MULTIMEDIA},
+            input_schema=FileStoreBlock.Input,
+            output_schema=FileStoreBlock.Output,
+            static_output=True,
+        )
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        graph_exec_id: str,
+        **kwargs,
+    ) -> BlockOutput:
+        file_path = store_media_file(
+            graph_exec_id=graph_exec_id,
+            file=input_data.file_in,
+            return_content=False,
+        )
+        yield "file_out", file_path
+
+
 class StoreValueBlock(Block):
     """
     This block allows you to provide a constant value as a block, in a stateless manner.
@@ -469,6 +508,48 @@ def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "updated_list", updated_list
 
 
+class FindInListBlock(Block):
+    class Input(BlockSchema):
+        list: List[Any] = SchemaField(description="The list to search in.")
+        value: Any = SchemaField(description="The value to search for.")
+
+    class Output(BlockSchema):
+        index: int = SchemaField(description="The index of the value in the list.")
+        found: bool = SchemaField(
+            description="Whether the value was found in the list."
+        )
+        not_found_value: Any = SchemaField(
+            description="The value that was not found in the list."
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="5e2c6d0a-1e37-489f-b1d0-8e1812b23333",
+            description="Finds the index of the value in the list.",
+            categories={BlockCategory.BASIC},
+            input_schema=FindInListBlock.Input,
+            output_schema=FindInListBlock.Output,
+            test_input=[
+                {"list": [1, 2, 3, 4, 5], "value": 3},
+                {"list": [1, 2, 3, 4, 5], "value": 6},
+            ],
+            test_output=[
+                ("index", 2),
+                ("found", True),
+                ("found", False),
+                ("not_found_value", 6),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            yield "index", input_data.list.index(input_data.value)
+            yield "found", True
+        except ValueError:
+            yield "found", False
+            yield "not_found_value", input_data.value
+
+
 class NoteBlock(Block):
     class Input(BlockSchema):
         text: str = SchemaField(description="The text to display in the sticky note.")
@@ -590,3 +671,47 @@ def run(self, input_data: Input, **kwargs) -> BlockOutput:
             yield "list", input_data.values
         except Exception as e:
             yield "error", f"Failed to create list: {str(e)}"
+
+
+class TypeOptions(enum.Enum):
+    STRING = "string"
+    NUMBER = "number"
+    BOOLEAN = "boolean"
+    LIST = "list"
+    DICTIONARY = "dictionary"
+
+
+class UniversalTypeConverterBlock(Block):
+    class Input(BlockSchema):
+        value: Any = SchemaField(
+            description="The value to convert to a universal type."
+        )
+        type: TypeOptions = SchemaField(description="The type to convert the value to.")
+
+    class Output(BlockSchema):
+        value: Any = SchemaField(description="The converted value.")
+
+    def __init__(self):
+        super().__init__(
+            id="95d1b990-ce13-4d88-9737-ba5c2070c97b",
+            description="This block is used to convert a value to a universal type.",
+            categories={BlockCategory.BASIC},
+            input_schema=UniversalTypeConverterBlock.Input,
+            output_schema=UniversalTypeConverterBlock.Output,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            converted_value = convert(
+                input_data.value,
+                {
+                    TypeOptions.STRING: str,
+                    TypeOptions.NUMBER: float,
+                    TypeOptions.BOOLEAN: bool,
+                    TypeOptions.LIST: list,
+                    TypeOptions.DICTIONARY: dict,
+                }[input_data.type],
+            )
+            yield "value", converted_value
+        except Exception as e:
+            yield "error", f"Failed to convert value: {str(e)}"

autogpt_platform/backend/backend/blocks/branching.py

@@ -107,3 +107,83 @@ def run(self, input_data: Input, **kwargs) -> BlockOutput:
             yield "yes_output", yes_value
         else:
             yield "no_output", no_value
+
+
+class IfInputMatchesBlock(Block):
+    class Input(BlockSchema):
+        input: Any = SchemaField(
+            description="The input to match against",
+            placeholder="For example: 10 or 'hello' or True",
+        )
+        value: Any = SchemaField(
+            description="The value to output if the input matches",
+            placeholder="For example: 'Greater' or 20 or False",
+        )
+        yes_value: Any = SchemaField(
+            description="The value to output if the input matches",
+            placeholder="For example: 'Greater' or 20 or False",
+            default=None,
+        )
+        no_value: Any = SchemaField(
+            description="The value to output if the input does not match",
+            placeholder="For example: 'Greater' or 20 or False",
+            default=None,
+        )
+
+    class Output(BlockSchema):
+        result: bool = SchemaField(
+            description="The result of the condition evaluation (True or False)"
+        )
+        yes_output: Any = SchemaField(
+            description="The output value if the condition is true"
+        )
+        no_output: Any = SchemaField(
+            description="The output value if the condition is false"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="6dbbc4b3-ca6c-42b6-b508-da52d23e13f2",
+            input_schema=IfInputMatchesBlock.Input,
+            output_schema=IfInputMatchesBlock.Output,
+            description="Handles conditional logic based on comparison operators",
+            categories={BlockCategory.LOGIC},
+            test_input=[
+                {
+                    "input": 10,
+                    "value": 10,
+                    "yes_value": "Greater",
+                    "no_value": "Not greater",
+                },
+                {
+                    "input": 10,
+                    "value": 20,
+                    "yes_value": "Greater",
+                    "no_value": "Not greater",
+                },
+                {
+                    "input": 10,
+                    "value": None,
+                    "yes_value": "Yes",
+                    "no_value": "No",
+                },
+            ],
+            test_output=[
+                ("result", True),
+                ("yes_output", "Greater"),
+                ("result", False),
+                ("no_output", "Not greater"),
+                ("result", False),
+                ("no_output", "No"),
+                # ("result", True),
+                # ("yes_output", "Yes"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        if input_data.input == input_data.value or input_data.input is input_data.value:
+            yield "result", True
+            yield "yes_output", input_data.yes_value
+        else:
+            yield "result", False
+            yield "no_output", input_data.no_value