AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
Add block registry and updated
Swifty2dc0c97a5251
diff --git a/autogpt_platform/backend/backend/data/block.py b/autogpt_platform/backend/backend/data/block.pyindex b96211a829..1bf378dc5f 100644--- a/autogpt_platform/backend/backend/data/block.py+++ b/autogpt_platform/backend/backend/data/block.py@@ -1,3 +1,4 @@+import collectionsimport inspectimport loggingimport os@@ -9,6 +10,7 @@ from typing import (Any,Callable,ClassVar,+ Dict,Generic,Optional,Sequence,@@ -20,7 +22,8 @@ from typing import (import jsonrefimport jsonschema-from prisma.models import AgentBlock+from prisma import Json+from prisma.models import AgentBlock, BlocksRegistryfrom prisma.types import AgentBlockCreateInputfrom pydantic import BaseModel@@ -479,19 +482,50 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):return self.__class__.__name__def to_dict(self):- return {- "id": self.id,- "name": self.name,- "inputSchema": self.input_schema.jsonschema(),- "outputSchema": self.output_schema.jsonschema(),- "description": self.description,- "categories": [category.dict() for category in self.categories],- "contributors": [- contributor.model_dump() for contributor in self.contributors- ],- "staticOutput": self.static_output,- "uiType": self.block_type.value,- }+ # Sort categories by their name to ensure consistent ordering+ sorted_categories = [+ category.dict()+ for category in sorted(self.categories, key=lambda c: c.name)+ ]++ # Sort dictionary keys recursively for consistent ordering+ def sort_dict(obj):+ if isinstance(obj, dict):+ return collections.OrderedDict(+ sorted((k, sort_dict(v)) for k, v in obj.items())+ )+ elif isinstance(obj, list):+ # Check if all items in the list are primitive types that can be sorted+ if obj and all(+ isinstance(item, (str, int, float, bool, type(None)))+ for item in obj+ ):+ # Sort primitive lists for consistent ordering+ return sorted(obj, key=lambda x: (x is None, str(x)))+ else:+ # For lists of complex objects, process each item but maintain order+ return [sort_dict(item) for item in obj]+ return obj++ return collections.OrderedDict(+ [+ ("id", self.id),+ ("name", self.name),+ ("inputSchema", sort_dict(self.input_schema.jsonschema())),+ ("outputSchema", sort_dict(self.output_schema.jsonschema())),+ ("description", self.description),+ ("categories", sorted_categories),+ (+ "contributors",+ sorted(+ [contributor.model_dump() for contributor in self.contributors],+ key=lambda c: (c.get("name", ""), c.get("username", "")),+ ),+ ),+ ("staticOutput", self.static_output),+ ("uiType", self.block_type.value),+ ]+ )def get_info(self) -> BlockInfo:from backend.data.credit import get_block_cost@@ -738,3 +772,127 @@ def get_io_block_ids() -> Sequence[str]:for id, B in get_blocks().items()if B().block_type in (BlockType.INPUT, BlockType.OUTPUT)]+++async def get_block_registry() -> Dict[str, BlocksRegistry]:+ """+ Retrieves the BlocksRegistry from the database and returns a dictionary mapping+ block names to BlocksRegistry objects.++ Returns:+ Dict[str, BlocksRegistry]: A dictionary where each key is a block name and+ each value is a BlocksRegistry instance.+ """+ blocks = await BlocksRegistry.prisma().find_many()+ return {block.id: block for block in blocks}+++def recursive_json_compare(+ db_block_definition: Any, local_block_definition: Any+) -> bool:+ """+ Recursively compares two JSON objects for equality.++ Args:+ db_block_definition (Any): The JSON object from the database.+ local_block_definition (Any): The local JSON object to compare against.++ Returns:+ bool: True if the objects are equal, False otherwise.+ """+ if isinstance(db_block_definition, dict) and isinstance(+ local_block_definition, dict+ ):+ if set(db_block_definition.keys()) != set(local_block_definition.keys()):+ logger.error(+ f"Keys are not the same: {set(db_block_definition.keys())} != {set(local_block_definition.keys())}"+ )+ return False+ return all(+ recursive_json_compare(db_block_definition[k], local_block_definition[k])+ for k in db_block_definition+ )+ values_are_same = db_block_definition == local_block_definition+ if not values_are_same:+ logger.error(+ f"Values are not the same: {db_block_definition} != {local_block_definition}"+ )+ return values_are_same+++def check_block_same(db_block: BlocksRegistry, local_block: Block) -> bool:+ """+ Compares a database block with a local block.++ Args:+ db_block (BlocksRegistry): The block object from the database registry.+ local_block (Block[BlockSchema, BlockSchema]): The local block definition.++ Returns:+ bool: True if the blocks are equal, False otherwise.+ """+ local_block_instance = local_block() # type: ignore+ local_block_definition = local_block_instance.to_dict()+ db_block_definition = db_block.definition+ logger.info(+ f"Checking if block {local_block_instance.name} is the same as the database block {db_block.name}"+ )+ is_same = recursive_json_compare(db_block_definition, local_block_definition)+ return is_same+++def find_delta_blocks(+ db_blocks: Dict[str, BlocksRegistry], local_blocks: Dict[str, Block]+) -> Dict[str, Block]:+ """+ Finds the set of blocks that are new or changed compared to the database.++ Args:+ db_blocks (Dict[str, BlocksRegistry]): Existing blocks from the database, keyed by name.+ local_blocks (Dict[str, Block]): Local block definitions, keyed by name.++ Returns:+ Dict[str, Block]: Blocks that are missing from or different than the database, keyed by name.+ """+ block_update: Dict[str, Block] = {}+ for block_id, block in local_blocks.items():+ if block_id not in db_blocks:+ block_update[block_id] = block+ else:+ if not check_block_same(db_blocks[block_id], block):+ block_update[block_id] = block+ return block_update+++async def upsert_blocks_change_bulk(blocks: Dict[str, Block]):+ """+ Bulk upserts blocks into the database if changed.++ - Compares the provided local blocks to those in the database via their definition.+ - Inserts new or updated blocks.++ Args:+ blocks (Dict[str, Block]): Local block definitions to upsert.++ Returns:+ Dict[str, Block]: Blocks that were new or changed and upserted.+ """+ db_blocks = await get_block_registry()+ block_update = find_delta_blocks(db_blocks, blocks)+ logger.error(f"Upserting {len(block_update)} blocks of {len(blocks)} total blocks")+ for block_id, block in block_update.items():+ await BlocksRegistry.prisma().upsert(+ where={"id": block_id},+ data={+ "create": {+ "id": block_id,+ "name": block().__class__.__name__, # type: ignore+ "definition": Json(block.to_dict(block())), # type: ignore+ },+ "update": {+ "name": block().__class__.__name__, # type: ignore+ "definition": Json(block.to_dict(block())), # type: ignore+ },+ },+ )+ return block_updatediff --git a/autogpt_platform/backend/backend/data/block_test.py b/autogpt_platform/backend/backend/data/block_test.pynew file mode 100644index 0000000000..aff481e285--- /dev/null+++ b/autogpt_platform/backend/backend/data/block_test.py@@ -0,0 +1,191 @@+import json+from datetime import datetime++import pytest+from prisma.models import BlocksRegistry++from backend.blocks.basic import (+ FileStoreBlock,+ PrintToConsoleBlock,+ ReverseListOrderBlock,+ StoreValueBlock,+)+from backend.data.block import (+ check_block_same,+ find_delta_blocks,+ recursive_json_compare,+)+++async def test_recursive_json_compare():+ db_block_definition = {+ "a": 1,+ "b": 2,+ "c": 3,+ }+ local_block_definition = {+ "a": 1,+ "b": 2,+ "c": 3,+ }+ assert recursive_json_compare(db_block_definition, local_block_definition)+ assert not recursive_json_compare(+ db_block_definition, {**local_block_definition, "d": 4}+ )+ assert not recursive_json_compare(+ db_block_definition, {**local_block_definition, "a": 2}+ )+ assert not recursive_json_compare(+ db_block_definition, {**local_block_definition, "b": 3}+ )+ assert not recursive_json_compare(+ db_block_definition, {**local_block_definition, "c": 4}+ )+ assert not recursive_json_compare(+ db_block_definition, {**local_block_definition, "a": 1, "b": 2, "c": 3, "d": 4}+ )+ assert recursive_json_compare({}, {})+ assert recursive_json_compare({"a": 1}, {"a": 1})+ assert not recursive_json_compare({"a": 1}, {"b": 1})+ assert not recursive_json_compare({"a": 1}, {"a": 2})+ assert not recursive_json_compare({"a": 1}, {"a": [1, 2]})+ assert not recursive_json_compare({"a": 1}, {"a": {"b": 1}})+ assert not recursive_json_compare({"a": 1}, {"a": {"b": 2}})+ assert not recursive_json_compare({"a": 1}, {"a": {"b": [1, 2]}})+ assert not recursive_json_compare({"a": 1}, {"a": {"b": {"c": 1}}})+ assert not recursive_json_compare({"a": 1}, {"a": {"b": {"c": 2}}})+++async def test_check_block_same():+ local_block = PrintToConsoleBlock()+ db_block = BlocksRegistry(+ id="f3b1c1b2-4c4f-4f0d-8d2f-4c4f0d8d2f4c",+ name=local_block.__class__.__name__,+ definition=json.dumps(local_block.to_dict()), # type: ignore To much type magic going on here+ updatedAt=datetime.now(),+ )+ assert check_block_same(db_block, local_block)+++async def test_check_block_not_same():+ local_block = PrintToConsoleBlock()+ local_block_data = local_block.to_dict()+ local_block_data["description"] = "Hello, World!"++ db_block = BlocksRegistry(+ id="f3b1c1b2-4c4f-4f0d-8d2f-4c4f0d8d2f4c",+ name=local_block.__class__.__name__,+ definition=json.dumps(local_block_data), # type: ignore To much type magic going on here+ updatedAt=datetime.now(),+ )+ assert not check_block_same(db_block, local_block)+++async def test_find_delta_blocks():+ now = datetime.now()+ store_value_block = StoreValueBlock()+ local_blocks = {+ PrintToConsoleBlock().id: PrintToConsoleBlock(),+ ReverseListOrderBlock().id: ReverseListOrderBlock(),+ FileStoreBlock().id: FileStoreBlock(),+ store_value_block.id: store_value_block,+ }+ db_blocks = {+ PrintToConsoleBlock().id: BlocksRegistry(+ id=PrintToConsoleBlock().id,+ name=PrintToConsoleBlock().__class__.__name__,+ definition=json.dumps(PrintToConsoleBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ ReverseListOrderBlock().id: BlocksRegistry(+ id=ReverseListOrderBlock().id,+ name=ReverseListOrderBlock().__class__.__name__,+ definition=json.dumps(ReverseListOrderBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ FileStoreBlock().id: BlocksRegistry(+ id=FileStoreBlock().id,+ name=FileStoreBlock().__class__.__name__,+ definition=json.dumps(FileStoreBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ }+ delta_blocks = find_delta_blocks(db_blocks, local_blocks)+ assert len(delta_blocks) == 1+ assert store_value_block.id in delta_blocks.keys()+ assert delta_blocks[store_value_block.id] == store_value_block+++async def test_find_delta_blocks_block_updated():+ now = datetime.now()+ store_value_block = StoreValueBlock()+ print_to_console_block_definition = PrintToConsoleBlock().to_dict()+ print_to_console_block_definition["description"] = "Hello, World!"+ local_blocks = {+ PrintToConsoleBlock().id: PrintToConsoleBlock(),+ ReverseListOrderBlock().id: ReverseListOrderBlock(),+ FileStoreBlock().id: FileStoreBlock(),+ store_value_block.id: store_value_block,+ }+ db_blocks = {+ PrintToConsoleBlock().id: BlocksRegistry(+ id=PrintToConsoleBlock().id,+ name=PrintToConsoleBlock().__class__.__name__,+ definition=json.dumps(print_to_console_block_definition), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ ReverseListOrderBlock().id: BlocksRegistry(+ id=ReverseListOrderBlock().id,+ name=ReverseListOrderBlock().__class__.__name__,+ definition=json.dumps(ReverseListOrderBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ FileStoreBlock().id: BlocksRegistry(+ id=FileStoreBlock().id,+ name=FileStoreBlock().__class__.__name__,+ definition=json.dumps(FileStoreBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ }+ delta_blocks = find_delta_blocks(db_blocks, local_blocks)+ assert len(delta_blocks) == 2+ assert store_value_block.id in delta_blocks.keys()+ assert delta_blocks[store_value_block.id] == store_value_block+ assert PrintToConsoleBlock().id in delta_blocks.keys()+++async def test_find_delta_block_no_diff():+ now = datetime.now()+ local_blocks = {+ PrintToConsoleBlock().id: PrintToConsoleBlock(),+ ReverseListOrderBlock().id: ReverseListOrderBlock(),+ FileStoreBlock().id: FileStoreBlock(),+ }+ db_blocks = {+ PrintToConsoleBlock().id: BlocksRegistry(+ id=PrintToConsoleBlock().id,+ name=PrintToConsoleBlock().__class__.__name__,+ definition=json.dumps(PrintToConsoleBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ ReverseListOrderBlock().id: BlocksRegistry(+ id=ReverseListOrderBlock().id,+ name=ReverseListOrderBlock().__class__.__name__,+ definition=json.dumps(ReverseListOrderBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ FileStoreBlock().id: BlocksRegistry(+ id=FileStoreBlock().id,+ name=FileStoreBlock().__class__.__name__,+ definition=json.dumps(FileStoreBlock().to_dict()), # type: ignore To much type magic going on here+ updatedAt=now,+ ),+ }+ delta_blocks = find_delta_blocks(db_blocks, local_blocks)+ assert len(delta_blocks) == 0diff --git a/autogpt_platform/backend/backend/data/model.py b/autogpt_platform/backend/backend/data/model.pyindex 1a34cde65d..e240f02a57 100644--- a/autogpt_platform/backend/backend/data/model.py+++ b/autogpt_platform/backend/backend/data/model.py@@ -523,13 +523,13 @@ class CredentialsMetaInput(BaseModel, Generic[CP, CT]):if hasattr(model_class, "allowed_providers") and hasattr(model_class, "allowed_cred_types"):- allowed_providers = model_class.allowed_providers()+ allowed_providers = sorted(model_class.allowed_providers())# If no specific providers (None), allow any stringif allowed_providers is None:schema["credentials_provider"] = ["string"] # Allow any string providerelse:schema["credentials_provider"] = allowed_providers- schema["credentials_types"] = model_class.allowed_cred_types()+ schema["credentials_types"] = sorted(model_class.allowed_cred_types())# Do not return anything, just mutate schema in placemodel_config = ConfigDict(diff --git a/autogpt_platform/backend/backend/sdk/db.py b/autogpt_platform/backend/backend/sdk/db.pyindex 292bf61275..b2cc0d1b80 100644--- a/autogpt_platform/backend/backend/sdk/db.py+++ b/autogpt_platform/backend/backend/sdk/db.py@@ -1,16 +1,98 @@from typing import Dictfrom prisma import Prisma+from prisma.models import ProviderRegistry as PrismaProviderRegistryfrom backend.sdk.provider import ProviderRegister-async def upsert_providers_bulk(providers: Dict[str, ProviderRegister]):+def is_providers_different(+ current_provider: PrismaProviderRegistry, new_provider: ProviderRegister+) -> bool:+ """+ Compare a current provider (as stored in the database) against a new provider registration+ and determine if they are different. This is done by converting the database model to a+ ProviderRegister and checking for equality (all fields compared).++ Args:+ current_provider (PrismaProviderRegistry): The provider as stored in the database.+ new_provider (ProviderRegister): The provider specification to compare.++ Returns:+ bool: True if the providers differ, False if they are effectively the same.+ """+ current_provider_register = ProviderRegister(+ name=current_provider.name,+ with_oauth=current_provider.with_oauth,+ client_id_env_var=current_provider.client_id_env_var,+ client_secret_env_var=current_provider.client_secret_env_var,+ with_api_key=current_provider.with_api_key,+ api_key_env_var=current_provider.api_key_env_var,+ with_user_password=current_provider.with_user_password,+ username_env_var=current_provider.username_env_var,+ password_env_var=current_provider.password_env_var,+ )+ if current_provider_register == new_provider:+ return False+ return True+++def find_delta_providers(+ current_providers: Dict[str, PrismaProviderRegistry],+ providers: Dict[str, ProviderRegister],+) -> Dict[str, ProviderRegister]:+ """+ Identify providers that are either new or updated compared to the current providers list.++ Args:+ current_providers (Dict[str, PrismaProviderRegistry]): Dictionary of current provider models keyed by provider name.+ providers (Dict[str, ProviderRegister]): Dictionary of new provider registrations keyed by provider name.++ Returns:+ Dict[str, ProviderRegister]: Providers that need to be added/updated in the registry.+ - Includes providers not in current_providers.+ - Includes providers where the data differs from what's in current_providers.+ """+ provider_update = {}+ for name, provider in providers.items():+ if name not in current_providers:+ provider_update[name] = provider+ else:+ if is_providers_different(current_providers[name], provider):+ provider_update[name] = provider++ return provider_update+++async def get_providers() -> Dict[str, PrismaProviderRegistry]:+ """+ Retrieve all provider registries from the database.++ Returns:+ Dict[str, PrismaProviderRegistry]: Dictionary of all current providers, keyed by provider name.+ """+ async with Prisma() as prisma:+ providers = await prisma.providerregistry.find_many()+ return {+ provider.name: PrismaProviderRegistry(**provider.model_dump())+ for provider in providers+ }+++async def upsert_providers_change_bulk(providers: Dict[str, ProviderRegister]):+ """+ Bulk upsert providers into the database after checking for changes.++ Args:+ providers (Dict[str, ProviderRegister]): Dictionary of new provider registrations keyed by provider name.+ """+ current_providers = await get_providers()+ provider_update = find_delta_providers(current_providers, providers)"""Async version of bulk upsert providers with all fields using transaction for atomicity"""async with Prisma() as prisma:async with prisma.tx() as tx:results = []- for name, provider in providers.items():+ for name, provider in provider_update.items():result = await tx.providerregistry.upsert(where={"name": name},data={diff --git a/autogpt_platform/backend/backend/sdk/db_test.py b/autogpt_platform/backend/backend/sdk/db_test.pynew file mode 100644index 0000000000..aa1eb335e4--- /dev/null+++ b/autogpt_platform/backend/backend/sdk/db_test.py@@ -0,0 +1,127 @@+from datetime import datetime++import pytest+from prisma.models import ProviderRegistry as PrismaProviderRegistry++from backend.sdk.db import find_delta_providers, is_providers_different+from backend.sdk.provider import ProviderRegister+++def test_is_providers_different_same():+ current_provider = PrismaProviderRegistry(+ name="test_provider",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID",+ client_secret_env_var="TEST_CLIENT_SECRET",+ with_api_key=True,+ api_key_env_var="TEST_API_KEY",+ with_user_password=True,+ username_env_var="TEST_USERNAME",+ password_env_var="TEST_PASSWORD",+ updatedAt=datetime.now(),+ )+ new_provider = ProviderRegister(+ name="test_provider",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID",+ client_secret_env_var="TEST_CLIENT_SECRET",+ with_api_key=True,+ api_key_env_var="TEST_API_KEY",+ with_user_password=True,+ username_env_var="TEST_USERNAME",+ password_env_var="TEST_PASSWORD",+ )+ assert not is_providers_different(current_provider, new_provider)+++def test_is_providers_different_different():+ current_provider = PrismaProviderRegistry(+ name="test_provider",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID",+ client_secret_env_var="TEST_CLIENT_SECRET",+ with_api_key=True,+ api_key_env_var="TEST_API_KEY",+ with_user_password=True,+ username_env_var="TEST_USERNAME",+ password_env_var="TEST_PASSWORD",+ updatedAt=datetime.now(),+ )+ new_provider = ProviderRegister(+ name="test_provider",+ with_oauth=False,+ with_api_key=True,+ api_key_env_var="TEST_API_KEY",+ with_user_password=True,+ username_env_var="TEST_USERNAME",+ password_env_var="TEST_PASSWORD",+ )+ assert is_providers_different(current_provider, new_provider)+++def test_find_delta_providers():+ current_providers = {+ "test_provider": PrismaProviderRegistry(+ name="test_provider",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID",+ client_secret_env_var="TEST_CLIENT_SECRET",+ with_api_key=True,+ api_key_env_var="TEST_API_KEY",+ with_user_password=True,+ username_env_var="TEST_USERNAME",+ password_env_var="TEST_PASSWORD",+ updatedAt=datetime.now(),+ ),+ "test_provider_2": PrismaProviderRegistry(+ name="test_provider_2",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID_2",+ client_secret_env_var="TEST_CLIENT_SECRET_2",+ with_api_key=True,+ api_key_env_var="TEST_API_KEY_2",+ with_user_password=True,+ username_env_var="TEST_USERNAME_2",+ password_env_var="TEST_PASSWORD_2",+ updatedAt=datetime.now(),+ ),+ }+ new_providers = {+ "test_provider": ProviderRegister(+ name="test_provider",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID",+ client_secret_env_var="TEST_CLIENT_SECRET",+ with_api_key=True,+ api_key_env_var="TEST_API_KEY",+ with_user_password=True,+ username_env_var="TEST_USERNAME",+ password_env_var="TEST_PASSWORD",+ ),+ "test_provider_2": ProviderRegister(+ name="test_provider_2",+ with_oauth=False,+ with_api_key=True,+ api_key_env_var="TEST_API_KEY_2",+ with_user_password=True,+ username_env_var="TEST_USERNAME_2",+ password_env_var="TEST_PASSWORD_2",+ ),+ "test_provider_3": ProviderRegister(+ name="test_provider_3",+ with_oauth=True,+ client_id_env_var="TEST_CLIENT_ID_3",+ client_secret_env_var="TEST_CLIENT_SECRET_3",+ with_api_key=False,+ with_user_password=True,+ username_env_var="TEST_USERNAME_3",+ password_env_var="TEST_PASSWORD_3",+ ),+ }+ assert find_delta_providers(current_providers, new_providers) == {+ "test_provider_2": new_providers["test_provider_2"],+ "test_provider_3": new_providers["test_provider_3"],+ }diff --git a/autogpt_platform/backend/backend/sdk/registry.py b/autogpt_platform/backend/backend/sdk/registry.pyindex 9980f936a4..637cb8aedc 100644--- a/autogpt_platform/backend/backend/sdk/registry.py+++ b/autogpt_platform/backend/backend/sdk/registry.py@@ -13,7 +13,7 @@ from backend.data.model import Credentialsfrom backend.integrations.oauth.base import BaseOAuthHandlerfrom backend.integrations.providers import ProviderNamefrom backend.integrations.webhooks._base import BaseWebhooksManager-from backend.sdk.db import upsert_providers_bulk+from backend.sdk.db import upsert_providers_change_bulkfrom backend.sdk.provider import ProviderRegisterif TYPE_CHECKING:@@ -282,7 +282,7 @@ class AutoRegistry:cls._provider_registry[item.provider] = new_cred- await upsert_providers_bulk(providers=cls._provider_registry)+ await upsert_providers_change_bulk(providers=cls._provider_registry)if hasattr(creds_store, "IntegrationCredentialsStore"):store_class = creds_store.IntegrationCredentialsStorediff --git a/autogpt_platform/backend/backend/server/rest_api.py b/autogpt_platform/backend/backend/server/rest_api.pyindex 7b70d64488..64e61ae03e 100644--- a/autogpt_platform/backend/backend/server/rest_api.py+++ b/autogpt_platform/backend/backend/server/rest_api.py@@ -16,6 +16,7 @@ from fastapi.middleware.gzip import GZipMiddlewarefrom fastapi.routing import APIRoutefrom prisma.errors import PrismaError+import backend.blocksimport backend.data.blockimport backend.data.dbimport backend.data.graph@@ -99,6 +100,9 @@ async def lifespan_context(app: fastapi.FastAPI):await backend.data.block.initialize_blocks()+ blocks = backend.blocks.load_all_blocks()++ await backend.data.block.upsert_blocks_change_bulk(blocks)await backend.data.user.migrate_and_encrypt_user_integrations()await backend.data.graph.fix_llm_provider_credentials()await backend.data.graph.migrate_llm_models(LlmModel.GPT4O)diff --git a/autogpt_platform/backend/migrations/20251017113143_provider_registry/migration.sql b/autogpt_platform/backend/migrations/20251017113143_provider_registry/migration.sqldeleted file mode 100644index 1f0c3b1239..0000000000--- a/autogpt_platform/backend/migrations/20251017113143_provider_registry/migration.sql+++ /dev/null@@ -1,14 +0,0 @@--- CreateTable-CREATE TABLE "ProviderRegistry" (- "name" TEXT NOT NULL,- "with_oauth" BOOLEAN NOT NULL DEFAULT false,- "client_id_env_var" TEXT,- "client_secret_env_var" TEXT,- "with_api_key" BOOLEAN NOT NULL DEFAULT false,- "api_key_env_var" TEXT,- "with_user_password" BOOLEAN NOT NULL DEFAULT false,- "username_env_var" TEXT,- "password_env_var" TEXT,-- CONSTRAINT "ProviderRegistry_pkey" PRIMARY KEY ("name")-);diff --git a/autogpt_platform/backend/migrations/20251017130227_add_block_provider_registry/migration.sql b/autogpt_platform/backend/migrations/20251017130227_add_block_provider_registry/migration.sqlnew file mode 100644index 0000000000..d6f2678273--- /dev/null+++ b/autogpt_platform/backend/migrations/20251017130227_add_block_provider_registry/migration.sql@@ -0,0 +1,31 @@+-- CreateTable+CREATE TABLE "ProviderRegistry" (+ "name" TEXT NOT NULL,+ "with_oauth" BOOLEAN NOT NULL DEFAULT false,+ "client_id_env_var" TEXT,+ "client_secret_env_var" TEXT,+ "with_api_key" BOOLEAN NOT NULL DEFAULT false,+ "api_key_env_var" TEXT,+ "with_user_password" BOOLEAN NOT NULL DEFAULT false,+ "username_env_var" TEXT,+ "password_env_var" TEXT,+ "updatedAt" TIMESTAMP(3) NOT NULL,++ CONSTRAINT "ProviderRegistry_pkey" PRIMARY KEY ("name")+);++-- CreateTable+CREATE TABLE "BlocksRegistry" (+ "id" TEXT NOT NULL,+ "name" TEXT NOT NULL,+ "definition" JSONB NOT NULL,+ "updatedAt" TIMESTAMP(3) NOT NULL,++ CONSTRAINT "BlocksRegistry_pkey" PRIMARY KEY ("id")+);++-- CreateIndex+CREATE INDEX "ProviderRegistry_updatedAt_idx" ON "ProviderRegistry"("updatedAt");++-- CreateIndex+CREATE INDEX "BlocksRegistry_updatedAt_idx" ON "BlocksRegistry"("updatedAt");diff --git a/autogpt_platform/backend/schema.prisma b/autogpt_platform/backend/schema.prismaindex 4a507fe6a0..9b95178d6a 100644--- a/autogpt_platform/backend/schema.prisma+++ b/autogpt_platform/backend/schema.prisma@@ -74,6 +74,18 @@ model ProviderRegistry {with_user_password Boolean @default(false)username_env_var String?password_env_var String?+ updatedAt DateTime @updatedAt++ @@index([updatedAt])+}++model BlocksRegistry {+ id String @id @default(uuid())+ name String+ definition Json+ updatedAt DateTime @updatedAt++ @@index([updatedAt])}enum OnboardingStep {diff --git a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/fields/CredentialField/models/APIKeyCredentialModal/useAPIKeyCredentialsModal.ts b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/fields/CredentialField/models/APIKeyCredentialModal/useAPIKeyCredentialsModal.tsindex 499cacf1ce..e2a176f684 100644--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/fields/CredentialField/models/APIKeyCredentialModal/useAPIKeyCredentialsModal.ts+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/fields/CredentialField/models/APIKeyCredentialModal/useAPIKeyCredentialsModal.ts@@ -7,7 +7,7 @@ import {usePostV1CreateCredentials,} from "@/app/api/__generated__/endpoints/integrations/integrations";import { useToast } from "@/components/molecules/Toast/use-toast";-import { APIKeyCredentials } from "@/app/api/__generated__/models/aPIKeyCredentials";+import { APIKeyCredentialsInput } from "@/app/api/__generated__/models/aPIKeyCredentialsInput";import { useQueryClient } from "@tanstack/react-query";import { useState } from "react";@@ -89,7 +89,7 @@ export function useAPIKeyCredentialsModal({api_key: values.apiKey,title: values.title,expires_at: expiresAt,- } as APIKeyCredentials,+ } as APIKeyCredentialsInput,});}