Merge branch 'master' into reinier/open-1806-implement-front-to-back-…

…github-oauth-support-on-blocks

.dockerignore

@@ -0,0 +1,40 @@
+# Ignore everything by default, selectively add things to context
+classic/run
+
+# AutoGPT
+!classic/original_autogpt/autogpt/
+!classic/original_autogpt/pyproject.toml
+!classic/original_autogpt/poetry.lock
+!classic/original_autogpt/README.md
+!classic/original_autogpt/tests/
+
+# Benchmark
+!classic/benchmark/agbenchmark/
+!classic/benchmark/pyproject.toml
+!classic/benchmark/poetry.lock
+!classic/benchmark/README.md
+
+# Forge
+!classic/forge/
+!classic/forge/pyproject.toml
+!classic/forge/poetry.lock
+!classic/forge/README.md
+
+# Frontend
+!classic/frontend/build/web/
+
+# Platform
+!autogpt_platform/
+
+# Explicitly re-ignore some folders
+.*
+**/__pycache__
+
+autogpt_platform/frontend/.next/
+autogpt_platform/frontend/node_modules
+autogpt_platform/frontend/.env.example
+autogpt_platform/frontend/.env.local
+autogpt_platform/backend/.env
+autogpt_platform/backend/.venv/
+
+autogpt_platform/market/.env

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

@@ -30,45 +30,9 @@ jobs:
       fail-fast: false
       matrix:
         python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
+    runs-on: ubuntu-latest
 
     steps:
-      - name: Setup PostgreSQL
-        uses: ikalnytskyi/action-setup-postgres@v6
-        with:
-          username: ${{ secrets.DB_USER || 'postgres' }}
-          password: ${{ secrets.DB_PASS || 'postgres' }}
-          database: postgres
-          port: 5432
-        id: postgres
-
-      # Quite slow on macOS (2~4 minutes to set up Docker)
-      # - name: Set up Docker (macOS)
-      #   if: runner.os == 'macOS'
-      #   uses: crazy-max/ghaction-setup-docker@v3
-
-      - name: Start MinIO service (Linux)
-        if: runner.os == 'Linux'
-        working-directory: "."
-        run: |
-          docker pull minio/minio:edge-cicd
-          docker run -d -p 9000:9000 minio/minio:edge-cicd
-
-      - name: Start MinIO service (macOS)
-        if: runner.os == 'macOS'
-        working-directory: ${{ runner.temp }}
-        run: |
-          brew install minio/stable/minio
-          mkdir data
-          minio server ./data &
-
-      # No MinIO on Windows:
-      # - Windows doesn't support running Linux Docker containers
-      # - It doesn't seem possible to start background processes on Windows. They are
-      #   killed after the step returns.
-      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
-
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -80,20 +44,22 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
+      - name: Setup Supabase
+        uses: supabase/setup-cli@v1
+        with:
+          version: latest
+
       - id: get_date
         name: Get date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
 
       - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          path: ~/.cache/pypoetry
           key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
 
       - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
         run: |
           curl -sSL https://install.python-poetry.org | python3 -
 
@@ -102,25 +68,26 @@ jobs:
             echo "$HOME/.local/bin" >> $GITHUB_PATH
           fi
 
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
-
       - name: Install Python dependencies
         run: poetry install
 
       - name: Generate Prisma Client
         run: poetry run prisma generate
 
+      - id: supabase
+        name: Start Supabase
+        working-directory: .
+        run: |
+          supabase init
+          supabase start --exclude postgres-meta,realtime,storage-api,imgproxy,inbucket,studio,edge-runtime,logflare,vector,supavisor
+          supabase status -o env | sed 's/="/=/; s/"$//' >> $GITHUB_OUTPUT
+        # outputs:
+        # DB_URL, API_URL, GRAPHQL_URL, ANON_KEY, SERVICE_ROLE_KEY, JWT_SECRET
+
       - name: Run Database Migrations
         run: poetry run prisma migrate dev --name updates
         env:
-          CONNECTION_STR: ${{ steps.postgres.outputs.connection-uri }}
+          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
 
       - id: lint
         name: Run Linter
@@ -136,17 +103,16 @@ jobs:
         if: success() || (failure() && steps.lint.outcome == 'failure')
         env:
           LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
+          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
+          SUPABASE_URL: ${{ steps.supabase.outputs.API_URL }}
+          SUPABASE_SERVICE_KEY: ${{ steps.supabase.outputs.SERVICE_ROLE_KEY }}
+          SUPABASE_JWT_SECRET: ${{ steps.supabase.outputs.JWT_SECRET }}
     env:
       CI: true
       PLAIN_OUTPUT: True
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      DB_USER: ${{ secrets.DB_USER || 'postgres' }}
-      DB_PASS: ${{ secrets.DB_PASS || 'postgres' }}
-      DB_NAME: postgres
-      DB_PORT: 5432
       RUN_ENV: local
       PORT: 8080
-      DATABASE_URL: postgresql://${{ secrets.DB_USER || 'postgres' }}:${{ secrets.DB_PASS || 'postgres' }}@localhost:5432/${{ secrets.DB_NAME || 'postgres'}}
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
 
       # - name: Upload coverage reports to Codecov
       #   uses: codecov/codecov-action@v4

autogpt_platform/README.md

@@ -27,7 +27,7 @@ To run the AutoGPT Platform, follow these steps:
 6. Run the following command:
 
    ```
-   docker compose -f docker-compose.combined.yml up -d
+   docker compose up -d
 
    ```
 
@@ -46,8 +46,8 @@ To run the AutoGPT Platform, follow these steps:
 
 Here are some useful Docker Compose commands for managing your AutoGPT Platform:
 
-- `docker compose -f docker-compose.combined.yml up -d`: Start the services in detached mode.
-- `docker compose -f docker-compose.combined.yml stop`: Stop the running services without removing them.
+- `docker compose up -d`: Start the services in detached mode.
+- `docker compose stop`: Stop the running services without removing them.
 - `docker compose rm`: Remove stopped service containers.
 - `docker compose build`: Build or rebuild services.
 - `docker compose down`: Stop and remove containers, networks, and volumes.

autogpt_platform/backend/backend/blocks/llm.py

@@ -320,7 +320,7 @@ def llm_call(input_data: AIStructuredResponseGeneratorBlock.Input) -> str:
             if output_name == "response":
                 return output_data["response"]
             else:
-                raise output_data
+                raise RuntimeError(output_data)
         raise ValueError("Failed to get a response from the LLM.")
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:

autogpt_platform/backend/backend/blocks/time_blocks.py

@@ -23,7 +23,7 @@ def __init__(self):
                 {"trigger": "Hello", "format": "{time}"},
             ],
             test_output=[
-                ("time", time.strftime("%H:%M:%S")),
+                ("time", lambda _: time.strftime("%H:%M:%S")),
             ],
         )
 

autogpt_platform/backend/backend/data/execution.py

@@ -398,19 +398,19 @@ def merge_execution_input(data: BlockInput) -> BlockInput:
 
     # Merge all input with <input_name>_$_<index> into a single list.
     items = list(data.items())
-    list_input: list[Any] = []
+
     for key, value in items:
         if LIST_SPLIT not in key:
             continue
         name, index = key.split(LIST_SPLIT)
         if not index.isdigit():
-            list_input.append((name, value, 0))
-        else:
-            list_input.append((name, value, int(index)))
+            raise ValueError(f"Invalid key: {key}, #{index} index must be an integer.")
 
-    for name, value, _ in sorted(list_input, key=lambda x: x[2]):
         data[name] = data.get(name, [])
-        data[name].append(value)
+        if int(index) >= len(data[name]):
+            # Pad list with empty string on missing indices.
+            data[name].extend([""] * (int(index) - len(data[name]) + 1))
+        data[name][int(index)] = value
 
     # Merge all input with <input_name>_#_<index> into a single dict.
     for key, value in items:

autogpt_platform/backend/backend/data/graph.py

@@ -1,17 +1,20 @@
 import asyncio
 import logging
 import uuid
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Literal
 
 import prisma.types
-from prisma.models import AgentGraph, AgentNode, AgentNodeLink
+from prisma.models import AgentGraph, AgentGraphExecution, AgentNode, AgentNodeLink
+from prisma.types import AgentGraphInclude
 from pydantic import BaseModel, PrivateAttr
 from pydantic_core import PydanticUndefinedType
 
 from backend.blocks.basic import AgentInputBlock, AgentOutputBlock
 from backend.data.block import BlockInput, get_block, get_blocks
 from backend.data.db import BaseDbModel, transaction
+from backend.data.execution import ExecutionStatus
 from backend.data.user import DEFAULT_USER_ID
 from backend.util import json
 
@@ -77,23 +80,65 @@ def from_db(node: AgentNode):
         return obj
 
 
+class ExecutionMeta(BaseDbModel):
+    execution_id: str
+    started_at: datetime
+    ended_at: datetime
+    duration: float
+    total_run_time: float
+    status: ExecutionStatus
+
+    @staticmethod
+    def from_agent_graph_execution(execution: AgentGraphExecution):
+        now = datetime.now(timezone.utc)
+        start_time = execution.startedAt or execution.createdAt
+        end_time = execution.updatedAt or now
+        duration = (end_time - start_time).total_seconds()
+
+        total_run_time = 0
+        if execution.AgentNodeExecutions:
+            for node_execution in execution.AgentNodeExecutions:
+                node_start = node_execution.startedTime or now
+                node_end = node_execution.endedTime or now
+                total_run_time += (node_end - node_start).total_seconds()
+
+        return ExecutionMeta(
+            id=execution.id,
+            execution_id=execution.id,
+            started_at=start_time,
+            ended_at=end_time,
+            duration=duration,
+            total_run_time=total_run_time,
+            status=ExecutionStatus(execution.executionStatus),
+        )
+
+
 class GraphMeta(BaseDbModel):
     version: int = 1
     is_active: bool = True
     is_template: bool = False
-
     name: str
     description: str
+    executions: list[ExecutionMeta] | None = None
 
     @staticmethod
     def from_db(graph: AgentGraph):
+        if graph.AgentGraphExecution:
+            executions = [
+                ExecutionMeta.from_agent_graph_execution(execution)
+                for execution in graph.AgentGraphExecution
+            ]
+        else:
+            executions = None
+
         return GraphMeta(
             id=graph.id,
             version=graph.version,
             is_active=graph.isActive,
             is_template=graph.isTemplate,
             name=graph.name or "",
             description=graph.description or "",
+            executions=executions,
         )
 
 
@@ -337,6 +382,7 @@ async def get_node(node_id: str) -> Node:
 
 
 async def get_graphs_meta(
+    include_executions: bool = False,
     filter_by: Literal["active", "template"] | None = "active",
     user_id: str | None = None,
 ) -> list[GraphMeta]:
@@ -345,6 +391,7 @@ async def get_graphs_meta(
     Default behaviour is to get all currently active graphs.
 
     Args:
+        include_executions: Whether to include executions in the graph metadata.
         filter_by: An optional filter to either select templates or active graphs.
 
     Returns:
@@ -364,6 +411,13 @@ async def get_graphs_meta(
         where=where_clause,
         distinct=["id"],
         order={"version": "desc"},
+        include=(
+            AgentGraphInclude(
+                AgentGraphExecution={"include": {"AgentNodeExecutions": True}}
+            )
+            if include_executions
+            else None
+        ),
     )
 
     if not graphs:

autogpt_platform/backend/backend/executor/manager.py

@@ -73,20 +73,28 @@ def __init__(
         self.prefix = f"[ExecutionManager|uid:{user_id}|gid:{graph_id}|nid:{node_id}]|geid:{graph_eid}|nid:{node_eid}|{block_name}]"
 
     def info(self, msg: str, **extra):
+        msg = self._wrap(msg, **extra)
         logger.info(msg, extra={"json_fields": {**self.metadata, **extra}})
 
     def warning(self, msg: str, **extra):
+        msg = self._wrap(msg, **extra)
         logger.warning(msg, extra={"json_fields": {**self.metadata, **extra}})
 
     def error(self, msg: str, **extra):
+        msg = self._wrap(msg, **extra)
         logger.error(msg, extra={"json_fields": {**self.metadata, **extra}})
 
     def debug(self, msg: str, **extra):
+        msg = self._wrap(msg, **extra)
         logger.debug(msg, extra={"json_fields": {**self.metadata, **extra}})
 
     def exception(self, msg: str, **extra):
+        msg = self._wrap(msg, **extra)
         logger.exception(msg, extra={"json_fields": {**self.metadata, **extra}})
 
+    def _wrap(self, msg: str, **extra):
+        return f"{self.prefix} {msg} {extra}"
+
 
 T = TypeVar("T")
 ExecutionStream = Generator[NodeExecution, None, None]