diff --git a/toolkits/arcade_engine_api/.pre-commit-config.yaml b/toolkits/arcade_engine_api/.pre-commit-config.yaml new file mode 100644 index 00000000..cd28957e --- /dev/null +++ b/toolkits/arcade_engine_api/.pre-commit-config.yaml @@ -0,0 +1,18 @@ +files: ^.*/engine_api/.* +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: "v4.4.0" + hooks: + - id: check-case-conflict + - id: check-merge-conflict + - id: check-toml + - id: check-yaml + - id: end-of-file-fixer + - id: trailing-whitespace + + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.6.7 + hooks: + - id: ruff + args: [--fix] + - id: ruff-format diff --git a/toolkits/arcade_engine_api/.ruff.toml b/toolkits/arcade_engine_api/.ruff.toml new file mode 100644 index 00000000..9519fe6c --- /dev/null +++ b/toolkits/arcade_engine_api/.ruff.toml @@ -0,0 +1,44 @@ +target-version = "py310" +line-length = 100 +fix = true + +[lint] +select = [ + # flake8-2020 + "YTT", + # flake8-bandit + "S", + # flake8-bugbear + "B", + # flake8-builtins + "A", + # flake8-comprehensions + "C4", + # flake8-debugger + "T10", + # flake8-simplify + "SIM", + # isort + "I", + # mccabe + "C90", + # pycodestyle + "E", "W", + # pyflakes + "F", + # pygrep-hooks + "PGH", + # pyupgrade + "UP", + # ruff + "RUF", + # tryceratops + "TRY", +] + +[lint.per-file-ignores] +"**/tests/*" = ["S101"] + +[format] +preview = true +skip-magic-trailing-comma = false diff --git a/toolkits/arcade_engine_api/LICENSE b/toolkits/arcade_engine_api/LICENSE new file mode 100644 index 00000000..dfbb8b76 --- /dev/null +++ b/toolkits/arcade_engine_api/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025, Arcade AI + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/toolkits/arcade_engine_api/Makefile b/toolkits/arcade_engine_api/Makefile new file mode 100644 index 00000000..86da492a --- /dev/null +++ b/toolkits/arcade_engine_api/Makefile @@ -0,0 +1,54 @@ +.PHONY: help + +help: + @echo "🛠️ github Commands:\n" + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' + +.PHONY: install +install: ## Install the uv environment and install all packages with dependencies + @echo "🚀 Creating virtual environment and installing all packages using uv" + @uv sync --active --all-extras --no-sources + @if [ -f .pre-commit-config.yaml ]; then uv run --no-sources pre-commit install; fi + @echo "✅ All packages and dependencies installed via uv" + +.PHONY: install-local +install-local: ## Install the uv environment and install all packages with dependencies with local Arcade sources + @echo "🚀 Creating virtual environment and installing all packages using uv" + @uv sync --active --all-extras + @if [ -f .pre-commit-config.yaml ]; then uv run pre-commit install; fi + @echo "✅ All packages and dependencies installed via uv" +.PHONY: build +build: clean-build ## Build wheel file using poetry + @echo "🚀 Creating wheel file" + uv build + +.PHONY: clean-build +clean-build: ## clean build artifacts + @echo "🗑️ Cleaning dist directory" + rm -rf dist + +.PHONY: test +test: ## Test the code with pytest + @echo "🚀 Testing code: Running pytest" + @uv run --no-sources pytest -W ignore -v --cov --cov-config=pyproject.toml --cov-report=xml + +.PHONY: coverage +coverage: ## Generate coverage report + @echo "coverage report" + @uv run --no-sources coverage report + @echo "Generating coverage report" + @uv run --no-sources coverage html + +.PHONY: bump-version +bump-version: ## Bump the version in the pyproject.toml file by a patch version + @echo "🚀 Bumping version in pyproject.toml" + uv version --no-sources --bump patch + +.PHONY: check +check: ## Run code quality tools. + @if [ -f .pre-commit-config.yaml ]; then\ + echo "🚀 Linting code: Running pre-commit";\ + uv run --no-sources pre-commit run -a;\ + fi + @echo "🚀 Static type checking: Running mypy" + @uv run --no-sources mypy --config-file=pyproject.toml diff --git a/toolkits/arcade_engine_api/arcade_engine_api/__init__.py b/toolkits/arcade_engine_api/arcade_engine_api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/toolkits/arcade_engine_api/arcade_engine_api/tools/__init__.py b/toolkits/arcade_engine_api/arcade_engine_api/tools/__init__.py new file mode 100644 index 00000000..ff3ab618 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/tools/__init__.py @@ -0,0 +1,1723 @@ +"""Arcade Starter Tools for Engine + +DO NOT EDIT THIS MODULE DIRECTLY. + +THIS MODULE WAS AUTO-GENERATED BY TRANSPILING THE API STARTER TOOL JSON DEFINITIONS +IN THE ../wrapper_tools DIRECTORY INTO PYTHON CODE. ANY CHANGES TO THIS MODULE WILL +BE OVERWRITTEN BY THE TRANSPILER. +""" + +import asyncio +import json +from enum import Enum +from typing import Annotated, Any + +import httpx +import jsonschema +from arcade_tdk import ToolContext, tool +from arcade_tdk.errors import RetryableToolError + +from .request_body_schemas import REQUEST_BODY_SCHEMAS + +# Retry configuration +INITIAL_RETRY_DELAY = 0.5 # seconds + +HTTP_CLIENT = httpx.AsyncClient( + timeout=httpx.Timeout(60.0, connect=10.0), + limits=httpx.Limits(max_keepalive_connections=20, max_connections=100), + transport=httpx.AsyncHTTPTransport(retries=3), + http2=True, + follow_redirects=True, +) + + +class ToolMode(str, Enum): + """Mode for tools with complex request bodies.""" + + GET_REQUEST_SCHEMA = "get_request_schema" + EXECUTE = "execute" + + +def remove_none_values(data: dict[str, Any]) -> dict[str, Any]: + return {k: v for k, v in data.items() if v is not None} + + +async def make_request( + url: str, + method: str, + params: dict[str, Any] | None = None, + headers: dict[str, Any] | None = None, + content: str | None = None, + data: dict[str, Any] | None = None, + auth: tuple[str, str] | None = None, + max_retries: int = 3, +) -> httpx.Response: + """Make an HTTP request with retry logic for 5xx server errors.""" + for attempt in range(max_retries): + try: + response = await HTTP_CLIENT.request( + url=url, + auth=auth, + method=method, + params=params, + headers=headers, + content=content, + ) + response.raise_for_status() + except httpx.HTTPStatusError as e: + # Only retry on 5xx server errors + if e.response.status_code >= 500 and attempt < max_retries - 1: + # Exponential backoff: 0.5s, 1s, 2s + await asyncio.sleep(INITIAL_RETRY_DELAY * (2**attempt)) + continue + # Re-raise for 4xx errors or if max retries reached + raise + except httpx.RequestError: + # Don't retry request errors (network issues are handled by transport) + raise + else: + return response + + # This should never be reached, but satisfies type checker + raise httpx.RequestError("Max retries exceeded") # noqa: TRY003 + + +async def make_request_with_schema_validation( + url: str, + method: str, + request_data: dict[str, Any], + schema: dict[str, Any], + auth: tuple[str, str] | None = None, + params: dict[str, Any] | None = None, + headers: dict[str, Any] | None = None, + max_retries: int = 3, +) -> httpx.Response: + """Make an HTTP request with schema validation on format errors.""" + try: + response = await make_request( + url=url, + auth=auth, + method=method, + params=params, + headers=headers, + content=json.dumps(request_data), + max_retries=max_retries, + ) + except httpx.HTTPStatusError as e: + # Only provide schema validation for format-related errors + if e.response.status_code in (400, 422): + # Run validation to provide additional context + is_valid, validation_error = validate_json_against_schema(request_data, schema) + + api_error_details = f"API returned {e.response.status_code}: {e.response.text}" + + if not is_valid: + # Schema validation found issues - additional context + additional_context = ( + f"{api_error_details}\n\n" + f"Schema validation found the following issues:\n" + f"{validation_error}" + ) + else: + # Schema validation passed - just show API error + additional_context = api_error_details + + raise RetryableToolError( + message=(f"API request failed with validation error: {e.response.status_code}"), + developer_message=api_error_details, + additional_prompt_content=additional_context, + ) from e + else: + # For non-validation errors, re-raise as-is + raise + else: + return response + + +def validate_json_against_schema( + json_data: dict[str, Any], schema: dict[str, Any] +) -> tuple[bool, str | None]: + """Validate JSON data against an OpenAPI/JSON Schema. + + This provides full JSON Schema Draft 7 validation including: + - Required fields, types, enums + - Pattern validation (regex) + - Format validation (email, uuid, date-time, etc.) + - Min/max length and values + - oneOf, anyOf, allOf + - And all other JSON Schema features + + Args: + json_data: The JSON data to validate + schema: The JSON Schema to validate against + + Returns: + Tuple of (is_valid, error_messages). If valid, error_messages is None. + If invalid, error_messages contains all validation errors. + """ + try: + validator = jsonschema.Draft7Validator( + schema, format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER + ) + # Collect ALL validation errors + errors = list(validator.iter_errors(json_data)) + if errors: + # Format all errors with their paths + error_messages = [] + for error in errors: + error_path = ".".join(str(p) for p in error.path) if error.path else "root" + error_messages.append(f"{error.message} at {error_path}") + # Join all errors with newlines + return False, "\n".join(error_messages) + else: + return True, None + except jsonschema.SchemaError as e: + return False, f"Invalid schema: {e.message}" + except Exception as e: + return False, f"Validation error: {e!s}" + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def list_available_auth_providers( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-providers-list'."]: + """Retrieve a list of available authentication providers. + + This tool fetches a paginated list of authentication providers accessible to the caller. It should be used when identifying or managing auth providers in the system.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/auth_providers", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def create_auth_provider( + context: ToolContext, + mode: Annotated[ + ToolMode, + "Operation mode: 'get_request_schema' returns the OpenAPI spec " + "for the request body, 'execute' performs the actual operation", + ], + request_body: Annotated[ + str | None, + "Stringified JSON representing the request body. Required when " + "mode is 'execute', ignored when mode is 'get_request_schema'", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-providers-create'."]: + """Create a new authentication provider. + + This tool is used to create a new authentication provider for the system, allowing integration with different authentication services. + + Note: Understanding the request schema is necessary to properly create + the stringified JSON input object for execution. + + Modes: + - GET_REQUEST_SCHEMA: Returns the schema. Only call if you don't + already have it. Do NOT call repeatedly if you already received + the schema. + - EXECUTE: Performs the operation with the provided request body + JSON. + + If you need the schema, call with mode='get_request_schema' ONCE, then execute. + """ # noqa: E501 + if mode == ToolMode.GET_REQUEST_SCHEMA: + return { + "request_body_schema": REQUEST_BODY_SCHEMAS["CREATEAUTHPROVIDER"], + "instructions": ( + "Use the request_body_schema to construct a valid JSON object. " + "Once you have populated the object following the schema " + "structure and requirements, call this tool again with " + "mode='execute' and the stringified JSON as the " + "request_body parameter. " + "Do NOT call the schema mode again - you already have " + "the schema now." + ), + } + + # Mode is EXECUTE - validate parameters + + # Validate request body is provided (not None or empty string) + # Note: Empty objects like {} are allowed - schema validation will check if valid + if request_body is None or request_body.strip() == "": + raise RetryableToolError( + message="Request body is required when mode is 'execute'", + developer_message="The request_body parameter was null or empty string", + additional_prompt_content=( + "The request body is required to perform this operation. " + "Use the schema below to construct a valid JSON object, " + "then call this tool again in execute mode with the " + "stringified JSON as the request_body parameter.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["CREATEAUTHPROVIDER"] + "\n```" + ), + ) + + # Parse JSON + try: + request_data = json.loads(request_body) + except json.JSONDecodeError as e: + raise RetryableToolError( + message=f"Invalid JSON in request body: {e!s}", + developer_message=f"JSON parsing failed: {e!s}", + additional_prompt_content=( + f"The request body contains invalid JSON. Error: {e!s}\n\n" + "Please provide a valid JSON string that matches the schema " + "below, then call this tool again in execute mode.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["CREATEAUTHPROVIDER"] + "\n```" + ), + ) from e + + response = await make_request_with_schema_validation( + url="https://api.arcade.dev/v1/admin/auth_providers", + method="POST", + request_data=request_data, + schema=json.loads(REQUEST_BODY_SCHEMAS["CREATEAUTHPROVIDER"]), + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_auth_provider_details( + context: ToolContext, + auth_provider_id: Annotated[str, "The ID of the authentication provider to retrieve."], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-providers-get'."]: + """Retrieve details of a specific authentication provider. + + Use this tool to obtain the details of a particular authentication provider by specifying its ID.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/auth_providers/{id}".format(id=auth_provider_id), # noqa: UP032 + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def delete_auth_provider( + context: ToolContext, + auth_provider_id: Annotated[str, "The ID of the authentication provider to delete."], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-providers-delete'."]: + """Delete a specific auth provider by ID. + + This tool deletes a specified authentication provider using its ID. It should be called when you need to remove an auth provider from the system.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/auth_providers/{id}".format(id=auth_provider_id), # noqa: UP032 + method="DELETE", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def update_auth_provider( + context: ToolContext, + mode: Annotated[ + ToolMode, + "Operation mode: 'get_request_schema' returns the OpenAPI spec " + "for the request body, 'execute' performs the actual operation", + ], + request_body: Annotated[ + str | None, + "Stringified JSON representing the request body. Required when " + "mode is 'execute', ignored when mode is 'get_request_schema'", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-providers-update'."]: + """Update an existing authentication provider. + + Use this tool to patch details of an existing authentication provider by providing its ID. This is useful when changes are needed in the authentication configuration. + + Note: Understanding the request schema is necessary to properly create + the stringified JSON input object for execution. + + Modes: + - GET_REQUEST_SCHEMA: Returns the schema. Only call if you don't + already have it. Do NOT call repeatedly if you already received + the schema. + - EXECUTE: Performs the operation with the provided request body + JSON. + + If you need the schema, call with mode='get_request_schema' ONCE, then execute. + """ # noqa: E501 + if mode == ToolMode.GET_REQUEST_SCHEMA: + return { + "request_body_schema": REQUEST_BODY_SCHEMAS["UPDATEAUTHPROVIDER"], + "instructions": ( + "Use the request_body_schema to construct a valid JSON object. " + "Once you have populated the object following the schema " + "structure and requirements, call this tool again with " + "mode='execute' and the stringified JSON as the " + "request_body parameter. " + "Do NOT call the schema mode again - you already have " + "the schema now." + ), + } + + # Mode is EXECUTE - validate parameters + + # Validate request body is provided (not None or empty string) + # Note: Empty objects like {} are allowed - schema validation will check if valid + if request_body is None or request_body.strip() == "": + raise RetryableToolError( + message="Request body is required when mode is 'execute'", + developer_message="The request_body parameter was null or empty string", + additional_prompt_content=( + "The request body is required to perform this operation. " + "Use the schema below to construct a valid JSON object, " + "then call this tool again in execute mode with the " + "stringified JSON as the request_body parameter.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["UPDATEAUTHPROVIDER"] + "\n```" + ), + ) + + # Parse JSON + try: + request_data = json.loads(request_body) + except json.JSONDecodeError as e: + raise RetryableToolError( + message=f"Invalid JSON in request body: {e!s}", + developer_message=f"JSON parsing failed: {e!s}", + additional_prompt_content=( + f"The request body contains invalid JSON. Error: {e!s}\n\n" + "Please provide a valid JSON string that matches the schema " + "below, then call this tool again in execute mode.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["UPDATEAUTHPROVIDER"] + "\n```" + ), + ) from e + + response = await make_request_with_schema_validation( + url="https://api.arcade.dev/v1/admin/auth_providers/{id}", + method="PATCH", + request_data=request_data, + schema=json.loads(REQUEST_BODY_SCHEMAS["UPDATEAUTHPROVIDER"]), + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def list_visible_secrets( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'secrets-list'."]: + """Retrieve all secrets visible to the caller. + + This tool fetches a list of all secrets that the caller has access to. It should be used when there is a need to view available secrets within the user's administrative scope.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/secrets", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def delete_secret_by_id( + context: ToolContext, + secret_id: Annotated[str, "The unique identifier of the secret to delete."], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'secrets-delete'."]: + """Deletes a secret using its unique ID. + + Use this tool to delete a specific secret identified by its ID. Useful when needing to permanently remove a secret from the system.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/secrets/{secret_id}".format(secret_id=secret_id), # noqa: UP032 + method="DELETE", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def manage_secret( + context: ToolContext, + secret_key: Annotated[ + str, + "The key of the secret to be created or updated in the storage system. It should be a unique identifier for the secret.", # noqa: E501 + ], + secret_value: Annotated[ + str, + "The new or updated value of the secret to be stored. It should be a string containing the secret information.", # noqa: E501 + ], + secret_description: Annotated[ + str | None, + "A description of the secret. Provide details about the secret's purpose or context.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'secrets-upsert'."]: + """Create or update a stored secret key-value pair. + + Use this tool to create a new secret or update an existing secret in the storage system. It should be called when secret management tasks are needed, such as adding new credentials or modifying existing ones.""" # noqa: E501 + request_data = remove_none_values({"description": secret_description, "value": secret_value}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/secrets/{secret_key}".format(secret_key=secret_key), # noqa: UP032 + method="POST", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_session_verification_settings( + context: ToolContext, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'session-verification-settings-get'." +]: + """Retrieve current session verification settings. + + Use this tool to obtain the latest session verification settings for your account or application. It's helpful for understanding the security measures currently in place for session verification.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/settings/session_verification", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def update_session_verification_settings( + context: ToolContext, + unsafe_skip_verification: Annotated[ + bool | None, "Set to true to skip the session verification, making it unsafe." + ] = None, + verifier_url: Annotated[ + str | None, + "The URL of the verifier service used for session verification. Provide a valid URL.", + ] = None, +) -> Annotated[ + dict[str, Any], "Response from the API endpoint 'session-verification-settings-update'." +]: + """Update session verification settings for a user. + + This tool updates the session verification settings for the user or entity making the call. It should be used when there's a need to modify how sessions are verified, reflecting any new security or configuration preferences.""" # noqa: E501 + request_data = remove_none_values({ + "unsafe_skip_verification": unsafe_skip_verification, + "verifier_url": verifier_url, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/settings/session_verification", + method="PUT", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def list_auth_connections( + context: ToolContext, + page_offset: Annotated[ + int | None, + "The starting point in the list for pagination. Useful for retrieving subsequent pages of data.", # noqa: E501 + ] = None, + page_size: Annotated[ + int | None, + "Number of auth connections to return per page. Use to control the size of the result set.", + ] = None, + provider_id: Annotated[str | None, "Unique identifier for the authentication provider."] = None, + user_id: Annotated[ + str | None, "The unique identifier for the user to list authentication connections for." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-connections-list'."]: + """Retrieve all authentication connections for users. + + Use this tool to get a comprehensive list of all authentication connections associated with users. Ideal for managing or auditing user authentication setups.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/user_connections", + method="GET", + params=remove_none_values({ + "provider.id": provider_id, + "user.id": user_id, + "limit": page_size, + "offset": page_offset, + }), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def delete_user_auth_connection( + context: ToolContext, + connection_id: Annotated[ + str, "The unique identifier for the user/auth provider connection to be deleted." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-connections-delete'."]: + """Deletes a user/auth provider connection. + + This tool deletes a connection between a user and an authentication provider. It should be called when a user needs to disconnect their account from an external auth provider.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/admin/user_connections/{id}".format(id=connection_id), # noqa: UP032 + method="DELETE", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def start_authorization_process( + context: ToolContext, + user_id: Annotated[ + str, "Unique identifier for the user. Required to start the authorization process." + ], + authorization_provider_id: Annotated[ + str | None, "The provider ID for authorization. One of ID or ProviderID must be set." + ] = None, + authorization_provider_type: Annotated[ + str | None, + "Specifies the type of authorization provider to be used, such as 'OAuth2', 'SAML', etc.", + ] = None, + authorization_requirement_id: Annotated[ + str | None, + "Set this ID for initiating authorization. Either this ID or the provider ID must be set.", + ] = None, + oauth2_scopes: Annotated[ + list[str] | None, + "A list of OAuth2 scopes that specify the level of access required for the authorization. Each scope should be provided as a string.", # noqa: E501 + ] = None, + redirection_uri_after_authorization: Annotated[ + str | None, + "Optional URI to redirect the user after authorization. If provided, the user will be redirected to this specific address once the authorization process is complete.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'initiate-authorization'."]: + """Starts the authorization process for given requirements. + + Use this tool to initiate the authorization process based on specified requirements. Ideal for cases where user authentication needs to be initiated or validated.""" # noqa: E501 + request_data = remove_none_values({ + "auth_requirement": { + "id": authorization_requirement_id, + "oauth2": {"scopes": oauth2_scopes}, + "provider_id": authorization_provider_id, + "provider_type": authorization_provider_type, + }, + "next_uri": redirection_uri_after_authorization, + "user_id": user_id, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/auth/authorize", + method="POST", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def confirm_user_authentication( + context: ToolContext, + authorization_flow_id: Annotated[ + str, "A unique identifier for the authorization flow to confirm the user's details." + ], + user_identifier: Annotated[ + str, "The unique identifier for the user to be confirmed during authentication." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'confirm-user-auth-flow'."]: + """Confirms a user's details during an authorization flow. + + Use this tool to confirm a user's details as part of an authorization flow. It should be called when there's a need to verify user details during authentication processes.""" # noqa: E501 + request_data = remove_none_values({ + "flow_id": authorization_flow_id, + "user_id": user_identifier, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/auth/confirm_user", + method="POST", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def check_auth_status( + context: ToolContext, + authorization_id: Annotated[ + str, "The unique ID for the authorization process to check its status." + ], + timeout_in_seconds: Annotated[ + int | None, "Specify the timeout duration in seconds. Maximum allowed is 59 seconds." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'auth-status'."]: + """Verify the ongoing authorization status of a tool. + + Use this tool to check the status of an ongoing authorization process for a specific tool. Ideal for monitoring when an authorization completes or times out.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/auth/status", + method="GET", + params=remove_none_values({"id": authorization_id, "wait": timeout_in_seconds}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def openai_chat_interaction( + context: ToolContext, + mode: Annotated[ + ToolMode, + "Operation mode: 'get_request_schema' returns the OpenAPI spec " + "for the request body, 'execute' performs the actual operation", + ], + request_body: Annotated[ + str | None, + "Stringified JSON representing the request body. Required when " + "mode is 'execute', ignored when mode is 'get_request_schema'", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'llm-chat'."]: + """Engage with language models using OpenAI's chat API. + + Use this tool to interact with language models via OpenAI's chat completions API, suitable for generating conversation responses. + + Note: Understanding the request schema is necessary to properly create + the stringified JSON input object for execution. + + Modes: + - GET_REQUEST_SCHEMA: Returns the schema. Only call if you don't + already have it. Do NOT call repeatedly if you already received + the schema. + - EXECUTE: Performs the operation with the provided request body + JSON. + + If you need the schema, call with mode='get_request_schema' ONCE, then execute. + """ # noqa: E501 + if mode == ToolMode.GET_REQUEST_SCHEMA: + return { + "request_body_schema": REQUEST_BODY_SCHEMAS["OPENAICHATINTERACTION"], + "instructions": ( + "Use the request_body_schema to construct a valid JSON object. " + "Once you have populated the object following the schema " + "structure and requirements, call this tool again with " + "mode='execute' and the stringified JSON as the " + "request_body parameter. " + "Do NOT call the schema mode again - you already have " + "the schema now." + ), + } + + # Mode is EXECUTE - validate parameters + + # Validate request body is provided (not None or empty string) + # Note: Empty objects like {} are allowed - schema validation will check if valid + if request_body is None or request_body.strip() == "": + raise RetryableToolError( + message="Request body is required when mode is 'execute'", + developer_message="The request_body parameter was null or empty string", + additional_prompt_content=( + "The request body is required to perform this operation. " + "Use the schema below to construct a valid JSON object, " + "then call this tool again in execute mode with the " + "stringified JSON as the request_body parameter.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["OPENAICHATINTERACTION"] + "\n```" + ), + ) + + # Parse JSON + try: + request_data = json.loads(request_body) + except json.JSONDecodeError as e: + raise RetryableToolError( + message=f"Invalid JSON in request body: {e!s}", + developer_message=f"JSON parsing failed: {e!s}", + additional_prompt_content=( + f"The request body contains invalid JSON. Error: {e!s}\n\n" + "Please provide a valid JSON string that matches the schema " + "below, then call this tool again in execute mode.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["OPENAICHATINTERACTION"] + "\n```" + ), + ) from e + + response = await make_request_with_schema_validation( + url="https://api.arcade.dev/v1/chat/completions", + method="POST", + request_data=request_data, + schema=json.loads(REQUEST_BODY_SCHEMAS["OPENAICHATINTERACTION"]), + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_engine_configuration( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'engine-config'."]: + """Fetch the current engine configuration settings. + + This tool retrieves the current configuration settings for the engine. It should be called when users need to access detailed information about the engine's setup or settings.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/config", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def retrieve_formatted_tools_list( + context: ToolContext, + filter_by_toolkit: Annotated[ + str | None, "Specify the toolkit name to filter the list of tools." + ] = None, + number_of_items_to_return: Annotated[ + int | None, "Specify the number of tools to return. Defaults to 25, with a maximum of 100." + ] = None, + offset_start_index: Annotated[ + int | None, "Offset from the start of the tools list. Default is 0." + ] = None, + provider_format: Annotated[ + str | None, + "Format the tools according to the provider's specifications. Accepts a string value.", + ] = None, + user_identifier: Annotated[ + str | None, "The ID of the user for whom the tool list is to be retrieved." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tools-list-formatted'."]: + """Fetches a formatted list of tools from engine configuration. + + Use this tool to retrieve a page of tools from the engine's configuration, which can be filtered by toolkit and formatted for a specific provider.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/formatted_tools", + method="GET", + params=remove_none_values({ + "toolkit": filter_by_toolkit, + "limit": number_of_items_to_return, + "offset": offset_start_index, + "format": provider_format, + "user_id": user_identifier, + }), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_formatted_tool_specification( + context: ToolContext, + tool_name: Annotated[ + str, "The name of the tool for which the formatted specification is requested." + ], + provider_format: Annotated[ + str | None, "Specifies the format of the tool as required by the provider." + ] = None, + user_id: Annotated[ + str | None, + "The identifier for the user requesting the tool specification. This should be a string.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tool-spec-formatted'."]: + """Fetches a formatted specification for a given tool. + + Use this to obtain detailed, formatted specifications for a specific tool from a provider.""" + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/formatted_tools/{name}".format(name=tool_name), # noqa: UP032 + method="GET", + params=remove_none_values({"format": provider_format, "user_id": user_id}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def check_arcade_engine_health( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'arcade-health'."]: + """Check the health status of the Arcade Engine. + + Use this tool to verify if the Arcade Engine service is currently healthy and operational.""" + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/health", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_model_context_protocol( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'mcp-endpoint'."]: + """Fetch data from the Model Context Protocol endpoint. + + This tool calls the Model Context Protocol (MCP) endpoint using a Streamable HTTP transport method. It should be used to retrieve information related to the MCP from the specified endpoint.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/mcp", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def model_context_protocol_stream( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'mcp-endpoint'."]: + """Access the Model Context Protocol for streaming data. + + This tool interacts with the Model Context Protocol endpoint using a streamable HTTP transport, allowing for real-time data communication. It's useful for scenarios where ongoing data exchange is necessary.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/mcp", + method="POST", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def delete_mcp_endpoint( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'mcp-endpoint'."]: + """Delete the Model Context Protocol endpoint data. + + This tool deletes data at the Model Context Protocol (MCP) endpoint, which supports Streamable HTTP transport. Use it to remove existing configurations or data tied to this endpoint.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/mcp", + method="DELETE", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def list_accessible_projects( + context: ToolContext, + bearer_token: Annotated[str, "A string containing the Bearer (JWT) token for authentication."], + items_to_skip: Annotated[ + int | None, "The number of projects to skip before starting to collect the result set." + ] = 0, + maximum_items_to_return: Annotated[ + int | None, "Specifies the maximum number of projects to return. Must be an integer." + ] = 25, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'list-projects'."]: + """Retrieve a list of accessible projects. + + This tool returns all projects that the caller has access to. It is useful for identifying projects available to a specific user or account.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/projects", + method="GET", + params=remove_none_values({"limit": maximum_items_to_return, "offset": items_to_skip}), + headers=remove_none_values({ + "Authorization": bearer_token, + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_project_details( + context: ToolContext, + authorization_token: Annotated[ + str, + "JWT token required for authentication. Should be provided in the format: 'Bearer '.", # noqa: E501 + ], + project_id: Annotated[ + str, + "The unique identifier for the project to retrieve details for. This should be a string matching the project's ID in the database.", # noqa: E501 + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'get-project'."]: + """Retrieve detailed information about a specific project. + + This tool fetches and returns detailed information for a given project based on its ID. Use it when you need to access specific details about a project.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/projects/{project_id}".format(project_id=project_id), # noqa: UP032 + method="GET", + params=remove_none_values({}), + headers=remove_none_values({ + "Authorization": authorization_token, + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_scheduled_tool_executions( + context: ToolContext, + items_limit: Annotated[ + int | None, "The number of scheduled tool executions to return. Defaults to 25, max is 100." + ] = None, + list_offset: Annotated[ + int | None, "The starting position in the list of scheduled tool executions, default is 0." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tool-scheduled-list'."]: + """Fetch a list of scheduled tool executions. + + Use this tool to retrieve a page of scheduled tool executions, useful for monitoring upcoming automated processes.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/scheduled_tools", + method="GET", + params=remove_none_values({"limit": items_limit, "offset": list_offset}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_scheduled_tool_details( + context: ToolContext, + scheduled_execution_id: Annotated[ + str, "The unique identifier for the scheduled tool execution to retrieve details for." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tool-scheduled-get'."]: + """Retrieve details for a specific scheduled tool execution. + + Use this tool to get information about a specific tool execution that has been scheduled, based on its unique identifier. It provides insights into the timing and parameters of the execution.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/scheduled_tools/{id}".format(id=scheduled_execution_id), # noqa: UP032 + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_swagger_specification( + context: ToolContext, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'swagger'."]: + """Retrieve the Swagger JSON specification for the API. + + Use this tool to access the Swagger JSON specification, which provides detailed information about the API's available endpoints and their usage.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/swagger", + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_tools_list( + context: ToolContext, + include_formats: Annotated[ + list[str] | None, + "List of tool formats to include in the response, specified by their names.", + ] = None, + items_per_page: Annotated[ + int | None, + "Specify the number of tools to return, with a maximum of 100. Defaults to 25 if not specified.", # noqa: E501 + ] = None, + start_offset: Annotated[ + int | None, "Offset to determine the starting point from the list of tools. Default is 0." + ] = None, + toolkit_name: Annotated[ + str | None, "Specifies the name of the toolkit to filter the tools list." + ] = None, + user_id: Annotated[ + str | None, + "The ID of the user requesting the tool list. It is used to filter the results for a specific user context.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tools-list-static'."]: + """Retrieve a list of tools from the engine configuration. + + Use this tool to get a paginated list of tools available in the engine configuration, with optional filtering by toolkit.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/tools", + method="GET", + params=remove_none_values({ + "toolkit": toolkit_name, + "limit": items_per_page, + "offset": start_offset, + "include_format": include_formats, + "user_id": user_id, + }), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def authorize_user_tool_access( + context: ToolContext, + tool_name_for_authorization: Annotated[ + str, "Specify the name of the tool to authorize the user for access." + ], + redirect_uri_after_authorization: Annotated[ + str | None, "Optional URI to redirect the user after authorization." + ] = None, + tool_version: Annotated[ + str | None, + "Specify the tool version to authorize. If not provided, any version will be used.", + ] = None, + user_id: Annotated[ + str | None, + "The unique identifier for a user. Required only when using an API key for authorization.", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tool-authorize'."]: + """Authorize a user to access a specific tool. + + This tool authorizes a user for a specific tool by its name. It should be called when a user needs permission to access a specific tool. The tool returns the authorization status.""" # noqa: E501 + request_data = remove_none_values({ + "next_uri": redirect_uri_after_authorization, + "tool_name": tool_name_for_authorization, + "tool_version": tool_version, + "user_id": user_id, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/tools/authorize", + method="POST", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def execute_tool( + context: ToolContext, + mode: Annotated[ + ToolMode, + "Operation mode: 'get_request_schema' returns the OpenAPI spec " + "for the request body, 'execute' performs the actual operation", + ], + request_body: Annotated[ + str | None, + "Stringified JSON representing the request body. Required when " + "mode is 'execute', ignored when mode is 'get_request_schema'", + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tool-execute'."]: + """Execute a specified tool with given parameters. + + This tool allows the execution of a specified tool by providing its name and necessary arguments. It's useful for triggering specific actions or processes as dictated by the tool's logic. + + Note: Understanding the request schema is necessary to properly create + the stringified JSON input object for execution. + + Modes: + - GET_REQUEST_SCHEMA: Returns the schema. Only call if you don't + already have it. Do NOT call repeatedly if you already received + the schema. + - EXECUTE: Performs the operation with the provided request body + JSON. + + If you need the schema, call with mode='get_request_schema' ONCE, then execute. + """ # noqa: E501 + if mode == ToolMode.GET_REQUEST_SCHEMA: + return { + "request_body_schema": REQUEST_BODY_SCHEMAS["EXECUTETOOL"], + "instructions": ( + "Use the request_body_schema to construct a valid JSON object. " + "Once you have populated the object following the schema " + "structure and requirements, call this tool again with " + "mode='execute' and the stringified JSON as the " + "request_body parameter. " + "Do NOT call the schema mode again - you already have " + "the schema now." + ), + } + + # Mode is EXECUTE - validate parameters + + # Validate request body is provided (not None or empty string) + # Note: Empty objects like {} are allowed - schema validation will check if valid + if request_body is None or request_body.strip() == "": + raise RetryableToolError( + message="Request body is required when mode is 'execute'", + developer_message="The request_body parameter was null or empty string", + additional_prompt_content=( + "The request body is required to perform this operation. " + "Use the schema below to construct a valid JSON object, " + "then call this tool again in execute mode with the " + "stringified JSON as the request_body parameter.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["EXECUTETOOL"] + "\n```" + ), + ) + + # Parse JSON + try: + request_data = json.loads(request_body) + except json.JSONDecodeError as e: + raise RetryableToolError( + message=f"Invalid JSON in request body: {e!s}", + developer_message=f"JSON parsing failed: {e!s}", + additional_prompt_content=( + f"The request body contains invalid JSON. Error: {e!s}\n\n" + "Please provide a valid JSON string that matches the schema " + "below, then call this tool again in execute mode.\n\n" + "Schema:\n\n```json\n" + REQUEST_BODY_SCHEMAS["EXECUTETOOL"] + "\n```" + ), + ) from e + + response = await make_request_with_schema_validation( + url="https://api.arcade.dev/v1/tools/execute", + method="POST", + request_data=request_data, + schema=json.loads(REQUEST_BODY_SCHEMAS["EXECUTETOOL"]), + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_tool_specification( + context: ToolContext, + tool_name: Annotated[ + str, + "The name of the tool whose specification is to be retrieved. This should match the tool's registered name.", # noqa: E501 + ], + formats_to_include: Annotated[ + list[str] | None, + "List of tool formats to include in the response. Provide formats as a list of strings.", + ] = None, + user_identifier: Annotated[ + str | None, "The unique identifier for the user requesting the tool specification." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tool-spec'."]: + """Retrieve the specification for a specific arcade tool. + + This tool returns the arcade tool specification for a specified tool by its name. It should be called when there's a need to understand the details or capabilities of a particular tool.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/tools/{name}".format(name=tool_name), # noqa: UP032 + method="GET", + params=remove_none_values({ + "include_format": formats_to_include, + "user_id": user_identifier, + }), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def list_workers( + context: ToolContext, + number_of_items_to_return: Annotated[ + int | None, + "The maximum number of worker items to return, with a default of 25 and a maximum of 100.", + ] = None, + start_offset: Annotated[ + int | None, "Offset from the start of the list for pagination. Defaults to 0." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-list'."]: + """Retrieve a list of all workers with their definitions. + + Use this tool to get information about all available workers and their definitions. This can be helpful for managing or reviewing the current worker pool.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers", + method="GET", + params=remove_none_values({"limit": number_of_items_to_return, "offset": start_offset}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def create_worker( + context: ToolContext, + worker_id: Annotated[ + str, "A unique identifier for the worker to be created. It should be a string." + ], + enable_worker: Annotated[ + bool | None, + "Set to true to enable the new worker upon creation, or false to keep it disabled.", + ] = None, + http_retry_attempts: Annotated[ + int | None, "Number of retry attempts for HTTP requests if a failure occurs." + ] = None, + http_secret_key: Annotated[ + str | None, + "A secret key used for HTTP authentication and authorization. It should be a secure string provided by the service.", # noqa: E501 + ] = None, + http_timeout_seconds: Annotated[ + int | None, + "The timeout duration for the HTTP connection, specified in seconds. This defines how long the system should wait for the HTTP request to complete before timing out.", # noqa: E501 + ] = None, + mcp_retry_attempts: Annotated[ + int | None, + "Specifies the number of retry attempts for MCP connections. Provide an integer value to define how many times the system should retry a connection if it fails.", # noqa: E501 + ] = None, + mcp_timeout_duration: Annotated[ + int | None, "The timeout duration for MCP operations in seconds. Must be an integer value." + ] = None, + worker_http_uri: Annotated[ + str | None, + "The HTTP URI for the worker's endpoint. This expects a valid URL string that specifies where the worker's service can be accessed.", # noqa: E501 + ] = None, + worker_resource_uri: Annotated[ + str | None, + "The URI for the worker's resource location or service endpoint. Provide the full URI as a string.", # noqa: E501 + ] = None, + worker_type: Annotated[ + str | None, + "Specifies the type of worker to be created. It should be a string indicating the category or role of the worker.", # noqa: E501 + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-create'."]: + """Create a new worker in the system. + + This tool is used to add a new worker to the system. It should be called when there's a need to register a new worker.""" # noqa: E501 + request_data = remove_none_values({ + "enabled": enable_worker, + "http": { + "retry": http_retry_attempts, + "secret": http_secret_key, + "timeout": http_timeout_seconds, + "uri": worker_http_uri, + }, + "id": worker_id, + "mcp": { + "retry": mcp_retry_attempts, + "timeout": mcp_timeout_duration, + "uri": worker_resource_uri, + }, + "type": worker_type, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers", + method="POST", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def test_worker_connection( + context: ToolContext, + worker_connection_type: Annotated[ + str, + "Specify the type of worker connection to test. It must be a string value indicating the category or mode of the worker.", # noqa: E501 + ], + http_uri: Annotated[ + str | None, "Specify the HTTP URI of the worker to test the connection." + ] = None, + mcp_uri: Annotated[ + str | None, "The URI for the MCP connection required to test a worker connection." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-test'."]: + """Test a worker connection before adding it to the system. + + Use this tool to verify if a worker connection is functioning properly before integrating it into your system.""" # noqa: E501 + request_data = remove_none_values({ + "http": {"uri": http_uri}, + "mcp": {"uri": mcp_uri}, + "type": worker_connection_type, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/test", + method="POST", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_worker_by_id( + context: ToolContext, + worker_id: Annotated[str, "The unique identifier for the worker to retrieve details."], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-get'."]: + """Retrieve worker details using their ID. + + Use this tool to obtain detailed information about a worker by providing their unique ID. Ideal for situations where specific worker data is required.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/{id}".format(id=worker_id), # noqa: UP032 + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def delete_worker( + context: ToolContext, + worker_id: Annotated[str, "The unique identifier for the worker to be deleted."], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-delete'."]: + """Deletes a specified worker from the system. + + Use this tool to remove a worker by providing their unique ID. It should be called when you need to permanently delete a worker record from the system.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/{id}".format(id=worker_id), # noqa: UP032 + method="DELETE", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def update_worker_details( + context: ToolContext, + worker_id: Annotated[str, "Unique identifier for the worker to be updated."], + enable_worker: Annotated[ + bool | None, "Set to 'true' to enable the worker or 'false' to disable it." + ] = None, + http_retry_attempts: Annotated[ + int | None, "Specify the number of retry attempts for HTTP requests." + ] = None, + http_timeout_duration: Annotated[ + int | None, + "The duration in seconds for the HTTP request timeout for updating a worker. Use an integer to specify the time limit.", # noqa: E501 + ] = None, + http_webhook_secret: Annotated[ + str | None, + "The secret key for authenticating HTTP webhook requests. It should be a secure string shared between sender and receiver.", # noqa: E501 + ] = None, + mcp_retry_attempts: Annotated[ + int | None, "Set the number of retry attempts for the MCP connection during update." + ] = None, + mcp_timeout_duration: Annotated[ + int | None, "Set the MCP request timeout duration in seconds. Expect an integer value." + ] = None, + mcp_uri: Annotated[ + str | None, + "The URI for the MCP (Message Control Protocol) endpoint to interact with the worker's messaging system.", # noqa: E501 + ] = None, + worker_http_uri: Annotated[ + str | None, "The HTTP URI for the worker's endpoint. Provide a valid URI string." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-update'."]: + """Update or modify details of a specific worker. + + Use this tool to update the information of a worker by specifying their unique ID. Ideal for scenarios where worker data needs modification or correction.""" # noqa: E501 + request_data = remove_none_values({ + "enabled": enable_worker, + "http": { + "retry": http_retry_attempts, + "secret": http_webhook_secret, + "timeout": http_timeout_duration, + "uri": worker_http_uri, + }, + "mcp": {"retry": mcp_retry_attempts, "timeout": mcp_timeout_duration, "uri": mcp_uri}, + }) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/{id}".format(id=worker_id), # noqa: UP032 + method="PATCH", + params=remove_none_values({}), + headers=remove_none_values({ + "Content-Type": "application/json", + "Authorization": context.get_secret("ARCADE_API_KEY"), + }), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def authorize_worker( + context: ToolContext, + worker_id: Annotated[str, "The unique identifier for the worker to be authorized."], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-authorize'."]: + """Authorize a worker based on their ID. + + This tool is used to verify and authorize a worker by their ID. It should be called when it's necessary to check if a worker has the appropriate permissions or status to perform certain tasks.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/{id}/authorize".format(id=worker_id), # noqa: UP032 + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def get_worker_health_status( + context: ToolContext, + worker_id: Annotated[ + str, "The unique identifier for the worker whose health status you want to check." + ], +) -> Annotated[dict[str, Any], "Response from the API endpoint 'workers-health'."]: + """Retrieve the health status of a worker. + + This tool is used to check the health status of a specific worker by their ID. It should be called when you need to monitor or verify the operational status of a worker.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/{id}/health".format(id=worker_id), # noqa: UP032 + method="GET", + params=remove_none_values({}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} + + +@tool(requires_secrets=["ARCADE_API_KEY"]) +async def fetch_tools_page( + context: ToolContext, + worker_id: Annotated[str, "The unique ID of the worker for which to retrieve the tools list."], + number_of_items: Annotated[ + int | None, + "Number of items to return in the result set. Default is 25 and the maximum is 100.", + ] = None, + start_offset: Annotated[ + int | None, "Offset from the start of the list for pagination. Defaults to 0." + ] = None, +) -> Annotated[dict[str, Any], "Response from the API endpoint 'tools-list'."]: + """Retrieve a list of tools for a specific worker. + + This tool is used to get a list of tools associated with a specific worker ID. It should be called when you need an overview of tools for a particular worker.""" # noqa: E501 + request_data = remove_none_values({}) + content = json.dumps(request_data) if request_data else None + response = await make_request( + url="https://api.arcade.dev/v1/workers/{id}/tools".format(id=worker_id), # noqa: UP032 + method="GET", + params=remove_none_values({"limit": number_of_items, "offset": start_offset}), + headers=remove_none_values({"Authorization": context.get_secret("ARCADE_API_KEY")}), + content=content, + ) + try: + return {"response_json": response.json()} + except Exception: + return {"response_text": response.text} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/tools/request_body_schemas.py b/toolkits/arcade_engine_api/arcade_engine_api/tools/request_body_schemas.py new file mode 100644 index 00000000..b6e4198a --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/tools/request_body_schemas.py @@ -0,0 +1,17 @@ +"""Request Body Schemas for API Tools + +DO NOT EDIT THIS MODULE DIRECTLY. + +THIS MODULE WAS AUTO-GENERATED AND CONTAINS OpenAPI REQUEST BODY SCHEMAS +FOR TOOLS WITH COMPLEX REQUEST BODIES. ANY CHANGES TO THIS MODULE WILL +BE OVERWRITTEN BY THE TRANSPILER. +""" + +from typing import Any + +REQUEST_BODY_SCHEMAS: dict[str, Any] = { + "CREATEAUTHPROVIDER": '{"required": ["id"], "type": "object", "properties": {"description": {"maxLength": 1000, "type": "string"}, "external_id": {"maxLength": 50, "type": "string", "description": "The unique external ID for the auth provider"}, "id": {"maxLength": 100, "type": "string"}, "oauth2": {"required": ["client_id"], "type": "object", "properties": {"authorize_request": {"required": ["endpoint"], "type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}}}, "client_id": {"maxLength": 1000, "type": "string"}, "client_secret": {"maxLength": 1000, "type": "string"}, "pkce": {"type": "object", "properties": {"code_challenge_method": {"type": "string"}, "enabled": {"type": "boolean"}}}, "refresh_request": {"required": ["endpoint"], "type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}}}, "scope_delimiter": {"type": "string", "enum": [",", " "]}, "token_introspection_request": {"required": ["endpoint", "triggers"], "type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}, "triggers": {"type": "object", "properties": {"on_token_grant": {"type": "boolean"}, "on_token_refresh": {"type": "boolean"}}}}}, "token_request": {"required": ["endpoint"], "type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}}}, "user_info_request": {"required": ["endpoint", "triggers"], "type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}, "triggers": {"type": "object", "properties": {"on_token_grant": {"type": "boolean"}, "on_token_refresh": {"type": "boolean"}}}}}}}, "provider_id": {"type": "string"}, "status": {"type": "string"}, "type": {"type": "string"}}}', # noqa: E501 + "UPDATEAUTHPROVIDER": '{"type": "object", "properties": {"description": {"maxLength": 1000, "type": "string"}, "id": {"maxLength": 100, "type": "string"}, "oauth2": {"type": "object", "properties": {"authorize_request": {"type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}}}, "client_id": {"maxLength": 1000, "type": "string"}, "client_secret": {"maxLength": 1000, "type": "string"}, "pkce": {"type": "object", "properties": {"code_challenge_method": {"type": "string"}, "enabled": {"type": "boolean"}}}, "refresh_request": {"type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}}}, "scope_delimiter": {"type": "string", "enum": [",", " "]}, "token_request": {"type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}}}, "user_info_request": {"type": "object", "properties": {"auth_method": {"type": "string"}, "endpoint": {"maxLength": 1000, "type": "string"}, "method": {"type": "string"}, "params": {"type": "object", "additionalProperties": {"type": "string"}}, "request_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_content_type": {"type": "string", "enum": ["application/x-www-form-urlencoded", "application/json"]}, "response_map": {"type": "object", "additionalProperties": {"type": "string"}}, "triggers": {"type": "object", "properties": {"on_token_grant": {"type": "boolean"}, "on_token_refresh": {"type": "boolean"}}}}}}}, "provider_id": {"type": "string"}, "status": {"type": "string"}, "type": {"type": "string"}}}', # noqa: E501 + "OPENAICHATINTERACTION": '{"type": "object", "properties": {"frequency_penalty": {"type": "number"}, "logit_bias": {"type": "object", "additionalProperties": {"type": "integer"}, "description": "LogitBias is must be a token id string (specified by their token ID in the tokenizer), not a word string.\nincorrect: `"logit_bias":{"You": 6}`, correct: `"logit_bias":{"1639": 6}`\nrefs: https://platform.openai.com/docs/api-reference/chat/create#chat/create-logit_bias"}, "logprobs": {"type": "boolean", "description": "LogProbs indicates whether to return log probabilities of the output tokens or not.\nIf true, returns the log probabilities of each output token returned in the content of message.\nThis option is currently not available on the gpt-4-vision-preview model."}, "max_tokens": {"type": "integer"}, "messages": {"type": "array", "items": {"required": ["content", "role"], "type": "object", "properties": {"content": {"type": "string", "description": "The content of the message."}, "name": {"type": "string", "description": "tool Name"}, "role": {"type": "string", "description": "The role of the author of this message. One of system, user, tool, or assistant."}, "tool_call_id": {"type": "string", "description": "tool_call_id"}, "tool_calls": {"type": "array", "description": "tool calls if any", "items": {"type": "object", "properties": {"function": {"type": "object", "properties": {"arguments": {"type": "string"}, "name": {"type": "string"}}}, "id": {"type": "string"}, "type": {"type": "string", "enum": ["function"], "x-enum-varnames": ["ToolTypeFunction"]}}}}}}}, "model": {"type": "string"}, "n": {"type": "integer"}, "parallel_tool_calls": {"type": "boolean", "description": "Disable the default behavior of parallel tool calls by setting it: false."}, "presence_penalty": {"type": "number"}, "response_format": {"type": "object", "properties": {"type": {"type": "string", "enum": ["json_object", "text"], "x-enum-varnames": ["ResponseFormatJSON", "ResponseFormatText"]}}}, "seed": {"type": "integer"}, "stop": {"type": "array", "items": {"type": "string"}}, "stream": {"type": "boolean"}, "stream_options": {"type": "object", "description": "Options for streaming response. Only set this when you set stream: true.", "allOf": [{"type": "object", "properties": {"include_usage": {"type": "boolean", "description": "If set, an additional chunk will be streamed before the data: [DONE] message.\nThe usage field on this chunk shows the token usage statistics for the entire request,\nand the choices field will always be an empty array.\nAll other chunks will also include a usage field, but with a null value."}}}]}, "temperature": {"type": "number"}, "tool_choice": {"type": "object", "description": "This can be either a string or an ToolChoice object."}, "tools": {"type": "object"}, "top_logprobs": {"type": "integer", "description": "TopLogProbs is an integer between 0 and 5 specifying the number of most likely tokens to return at each\ntoken position, each with an associated log probability.\nlogprobs must be set to true if this parameter is used."}, "top_p": {"type": "number"}, "user": {"type": "string"}}}', # noqa: E501 + "EXECUTETOOL": '{"required": ["tool_name"], "type": "object", "properties": {"include_error_stacktrace": {"type": "boolean", "description": "Whether to include the error stacktrace in the response. If not provided, the error stacktrace is not included."}, "input": {"type": "object", "description": "JSON input to the tool, if any", "allOf": [{"type": "object", "additionalProperties": true}]}, "run_at": {"type": "string", "description": "The time at which the tool should be run (optional). If not provided, the tool is run immediately. Format ISO 8601: YYYY-MM-DDTHH:MM:SS"}, "tool_name": {"type": "string"}, "tool_version": {"type": "string", "description": "The tool version to use (optional). If not provided, any version is used"}, "user_id": {"type": "string"}}}', # noqa: E501 +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/AuthorizeUserToolAccess.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/AuthorizeUserToolAccess.json new file mode 100644 index 00000000..1933be69 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/AuthorizeUserToolAccess.json @@ -0,0 +1,203 @@ +{ + "name": "AuthorizeUserToolAccess", + "fully_qualified_name": "EngineApi.AuthorizeUserToolAccess@0.1.0", + "description": "Authorize a user to access a specific tool.\n\nThis tool authorizes a user for a specific tool by its name. It should be called when a user needs permission to access a specific tool. The tool returns the authorization status.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "tool_name_for_authorization", + "required": true, + "description": "Specify the name of the tool to authorize the user for access.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "tool_name" + }, + { + "name": "redirect_uri_after_authorization", + "required": false, + "description": "Optional URI to redirect the user after authorization.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Optional: if provided, the user will be redirected to this URI after authorization" + }, + "inferrable": true, + "http_endpoint_parameter_name": "next_uri" + }, + { + "name": "tool_version", + "required": false, + "description": "Specify the tool version to authorize. If not provided, any version will be used.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Optional: if not provided, any version is used" + }, + "inferrable": true, + "http_endpoint_parameter_name": "tool_version" + }, + { + "name": "user_id", + "required": false, + "description": "The unique identifier for a user. Required only when using an API key for authorization.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Required only when calling with an API key" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tool-authorize'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/tools/authorize", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "next_uri", + "tool_parameter_name": "redirect_uri_after_authorization", + "description": "Optional: if provided, the user will be redirected to this URI after authorization", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Optional: if provided, the user will be redirected to this URI after authorization" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "tool_name", + "tool_parameter_name": "tool_name_for_authorization", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "tool_version", + "tool_parameter_name": "tool_version", + "description": "Optional: if not provided, any version is used", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Optional: if not provided, any version is used" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_id", + "description": "Required only when calling with an API key", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Required only when calling with an API key" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Tool authorization request\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"tool_name\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"next_uri\": {\n \"type\": \"string\",\n \"description\": \"Optional: if provided, the user will be redirected to this URI after authorization\"\n },\n \"tool_name\": {\n \"type\": \"string\"\n },\n \"tool_version\": {\n \"type\": \"string\",\n \"description\": \"Optional: if not provided, any version is used\"\n },\n \"user_id\": {\n \"type\": \"string\",\n \"description\": \"Required only when calling with an API key\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/AuthorizeWorker.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/AuthorizeWorker.json new file mode 100644 index 00000000..038ef737 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/AuthorizeWorker.json @@ -0,0 +1,104 @@ +{ + "name": "AuthorizeWorker", + "fully_qualified_name": "EngineApi.AuthorizeWorker@0.1.0", + "description": "Authorize a worker based on their ID.\n\nThis tool is used to verify and authorize a worker by their ID. It should be called when it's necessary to check if a worker has the appropriate permissions or status to perform certain tasks.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "The unique identifier for the worker to be authorized.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-authorize'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/{id}/authorize", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "Worker ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CheckArcadeEngineHealth.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CheckArcadeEngineHealth.json new file mode 100644 index 00000000..6d2766d7 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CheckArcadeEngineHealth.json @@ -0,0 +1,69 @@ +{ + "name": "CheckArcadeEngineHealth", + "fully_qualified_name": "EngineApi.CheckArcadeEngineHealth@0.1.0", + "description": "Check the health status of the Arcade Engine.\n\nUse this tool to verify if the Arcade Engine service is currently healthy and operational.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'arcade-health'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/health", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CheckAuthStatus.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CheckAuthStatus.json new file mode 100644 index 00000000..b5b06a23 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CheckAuthStatus.json @@ -0,0 +1,137 @@ +{ + "name": "CheckAuthStatus", + "fully_qualified_name": "EngineApi.CheckAuthStatus@0.1.0", + "description": "Verify the ongoing authorization status of a tool.\n\nUse this tool to check the status of an ongoing authorization process for a specific tool. Ideal for monitoring when an authorization completes or times out.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "authorization_id", + "required": true, + "description": "The unique ID for the authorization process to check its status.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Authorization ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + }, + { + "name": "timeout_in_seconds", + "required": false, + "description": "Specify the timeout duration in seconds. Maximum allowed is 59 seconds.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Timeout in seconds (max 59)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "wait" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-status'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/auth/status", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "authorization_id", + "description": "Authorization ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Authorization ID" + }, + "accepted_as": "query", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "wait", + "tool_parameter_name": "timeout_in_seconds", + "description": "Timeout in seconds (max 59)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Timeout in seconds (max 59)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ConfirmUserAuthentication.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ConfirmUserAuthentication.json new file mode 100644 index 00000000..fefd0a47 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ConfirmUserAuthentication.json @@ -0,0 +1,137 @@ +{ + "name": "ConfirmUserAuthentication", + "fully_qualified_name": "EngineApi.ConfirmUserAuthentication@0.1.0", + "description": "Confirms a user's details during an authorization flow.\n\nUse this tool to confirm a user's details as part of an authorization flow. It should be called when there's a need to verify user details during authentication processes.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "authorization_flow_id", + "required": true, + "description": "A unique identifier for the authorization flow to confirm the user's details.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "flow_id" + }, + { + "name": "user_identifier", + "required": true, + "description": "The unique identifier for the user to be confirmed during authentication.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'confirm-user-auth-flow'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/auth/confirm_user", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "flow_id", + "tool_parameter_name": "authorization_flow_id", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_identifier", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"User confirmation request\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"flow_id\",\n \"user_id\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"flow_id\": {\n \"type\": \"string\"\n },\n \"user_id\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CreateAuthProvider.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CreateAuthProvider.json new file mode 100644 index 00000000..2362da59 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CreateAuthProvider.json @@ -0,0 +1,1134 @@ +{ + "name": "CreateAuthProvider", + "fully_qualified_name": "EngineApi.CreateAuthProvider@0.1.0", + "description": "Create a new authentication provider.\n\nThis tool is used to create a new authentication provider for the system, allowing integration with different authentication services.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "auth_provider_details", + "required": true, + "description": "JSON object containing details of the auth provider to create, including OAuth2 configurations, external ID, and status.", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "description": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "external_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The unique external ID for the auth provider" + }, + "id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "oauth2": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "authorize_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "client_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "client_secret": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "pkce": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "code_challenge_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "enabled": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "refresh_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "scope_delimiter": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + ",", + " " + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "token_introspection_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "triggers": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "on_token_grant": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "on_token_refresh": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "token_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "user_info_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "triggers": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "on_token_grant": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "on_token_refresh": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "provider_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "status": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "The auth provider to create" + }, + "inferrable": true, + "http_endpoint_parameter_name": "requestBody" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-providers-create'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/auth_providers", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "requestBody", + "tool_parameter_name": "auth_provider_details", + "description": "The auth provider to create", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "description": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "external_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The unique external ID for the auth provider" + }, + "id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "oauth2": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "authorize_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "client_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "client_secret": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "pkce": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "code_challenge_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "enabled": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "refresh_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "scope_delimiter": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + ",", + " " + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "token_introspection_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "triggers": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "on_token_grant": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "on_token_refresh": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "token_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "user_info_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "triggers": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "on_token_grant": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "on_token_refresh": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "provider_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "status": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "The auth provider to create" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"The auth provider to create\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"id\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"description\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"external_id\": {\n \"maxLength\": 50,\n \"type\": \"string\",\n \"description\": \"The unique external ID for the auth provider\"\n },\n \"id\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n },\n \"oauth2\": {\n \"required\": [\n \"client_id\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"authorize_request\": {\n \"required\": [\n \"endpoint\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"client_id\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"client_secret\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"pkce\": {\n \"type\": \"object\",\n \"properties\": {\n \"code_challenge_method\": {\n \"type\": \"string\"\n },\n \"enabled\": {\n \"type\": \"boolean\"\n }\n }\n },\n \"refresh_request\": {\n \"required\": [\n \"endpoint\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"scope_delimiter\": {\n \"type\": \"string\",\n \"enum\": [\n \",\",\n \" \"\n ]\n },\n \"token_introspection_request\": {\n \"required\": [\n \"endpoint\",\n \"triggers\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"triggers\": {\n \"type\": \"object\",\n \"properties\": {\n \"on_token_grant\": {\n \"type\": \"boolean\"\n },\n \"on_token_refresh\": {\n \"type\": \"boolean\"\n }\n }\n }\n }\n },\n \"token_request\": {\n \"required\": [\n \"endpoint\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"user_info_request\": {\n \"required\": [\n \"endpoint\",\n \"triggers\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"triggers\": {\n \"type\": \"object\",\n \"properties\": {\n \"on_token_grant\": {\n \"type\": \"boolean\"\n },\n \"on_token_refresh\": {\n \"type\": \"boolean\"\n }\n }\n }\n }\n }\n }\n },\n \"provider_id\": {\n \"type\": \"string\"\n },\n \"status\": {\n \"type\": \"string\"\n },\n \"type\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": true, + "validate_request_body_schema": true + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CreateWorker.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CreateWorker.json new file mode 100644 index 00000000..3cb8d2a5 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/CreateWorker.json @@ -0,0 +1,401 @@ +{ + "name": "CreateWorker", + "fully_qualified_name": "EngineApi.CreateWorker@0.1.0", + "description": "Create a new worker in the system.\n\nThis tool is used to add a new worker to the system. It should be called when there's a need to register a new worker.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "A unique identifier for the worker to be created. It should be a string.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + }, + { + "name": "http_retry_attempts", + "required": false, + "description": "Number of retry attempts for HTTP requests if a failure occurs.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.retry" + }, + { + "name": "http_secret_key", + "required": false, + "description": "A secret key used for HTTP authentication and authorization. It should be a secure string provided by the service.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.secret" + }, + { + "name": "http_timeout_seconds", + "required": false, + "description": "The timeout duration for the HTTP connection, specified in seconds. This defines how long the system should wait for the HTTP request to complete before timing out.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.timeout" + }, + { + "name": "worker_http_uri", + "required": false, + "description": "The HTTP URI for the worker's endpoint. This expects a valid URL string that specifies where the worker's service can be accessed.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.uri" + }, + { + "name": "mcp_retry_attempts", + "required": false, + "description": "Specifies the number of retry attempts for MCP connections. Provide an integer value to define how many times the system should retry a connection if it fails.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.retry" + }, + { + "name": "mcp_timeout_duration", + "required": false, + "description": "The timeout duration for MCP operations in seconds. Must be an integer value.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.timeout" + }, + { + "name": "worker_resource_uri", + "required": false, + "description": "The URI for the worker's resource location or service endpoint. Provide the full URI as a string.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.uri" + }, + { + "name": "worker_type", + "required": false, + "description": "Specifies the type of worker to be created. It should be a string indicating the category or role of the worker.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "type" + }, + { + "name": "enable_worker", + "required": false, + "description": "Set to true to enable the new worker upon creation, or false to keep it disabled.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "enabled" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-create'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "enabled", + "tool_parameter_name": "enable_worker", + "description": "", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.retry", + "tool_parameter_name": "http_retry_attempts", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.secret", + "tool_parameter_name": "http_secret_key", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.timeout", + "tool_parameter_name": "http_timeout_seconds", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.uri", + "tool_parameter_name": "worker_http_uri", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.retry", + "tool_parameter_name": "mcp_retry_attempts", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.timeout", + "tool_parameter_name": "mcp_timeout_duration", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.uri", + "tool_parameter_name": "worker_resource_uri", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "type", + "tool_parameter_name": "worker_type", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Worker configuration to create\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"id\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"enabled\": {\n \"type\": \"boolean\"\n },\n \"http\": {\n \"required\": [\n \"retry\",\n \"secret\",\n \"timeout\",\n \"uri\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"retry\": {\n \"maximum\": 10,\n \"minimum\": 0,\n \"type\": \"integer\"\n },\n \"secret\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n },\n \"timeout\": {\n \"maximum\": 4000,\n \"minimum\": 1,\n \"type\": \"integer\"\n },\n \"uri\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n }\n }\n },\n \"id\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n },\n \"mcp\": {\n \"required\": [\n \"retry\",\n \"timeout\",\n \"uri\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"retry\": {\n \"maximum\": 10,\n \"minimum\": 0,\n \"type\": \"integer\"\n },\n \"timeout\": {\n \"maximum\": 4000,\n \"minimum\": 1,\n \"type\": \"integer\"\n },\n \"uri\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n }\n }\n },\n \"type\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteAuthProvider.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteAuthProvider.json new file mode 100644 index 00000000..f1d158fd --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteAuthProvider.json @@ -0,0 +1,104 @@ +{ + "name": "DeleteAuthProvider", + "fully_qualified_name": "EngineApi.DeleteAuthProvider@0.1.0", + "description": "Delete a specific auth provider by ID.\n\nThis tool deletes a specified authentication provider using its ID. It should be called when you need to remove an auth provider from the system.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "auth_provider_id", + "required": true, + "description": "The ID of the authentication provider to delete.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The ID of the auth provider to delete" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-providers-delete'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/auth_providers/{id}", + "http_method": "DELETE", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "auth_provider_id", + "description": "The ID of the auth provider to delete", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The ID of the auth provider to delete" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteMcpEndpoint.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteMcpEndpoint.json new file mode 100644 index 00000000..93c156be --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteMcpEndpoint.json @@ -0,0 +1,69 @@ +{ + "name": "DeleteMcpEndpoint", + "fully_qualified_name": "EngineApi.DeleteMcpEndpoint@0.1.0", + "description": "Delete the Model Context Protocol endpoint data.\n\nThis tool deletes data at the Model Context Protocol (MCP) endpoint, which supports Streamable HTTP transport. Use it to remove existing configurations or data tied to this endpoint.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'mcp-endpoint'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/mcp", + "http_method": "DELETE", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteSecretById.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteSecretById.json new file mode 100644 index 00000000..1e280aa3 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteSecretById.json @@ -0,0 +1,104 @@ +{ + "name": "DeleteSecretById", + "fully_qualified_name": "EngineApi.DeleteSecretById@0.1.0", + "description": "Deletes a secret using its unique ID.\n\nUse this tool to delete a specific secret identified by its ID. Useful when needing to permanently remove a secret from the system.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "secret_id", + "required": true, + "description": "The unique identifier of the secret to delete.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The ID of the secret to delete" + }, + "inferrable": true, + "http_endpoint_parameter_name": "secret_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'secrets-delete'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/secrets/{secret_id}", + "http_method": "DELETE", + "headers": {}, + "parameters": [ + { + "name": "secret_id", + "tool_parameter_name": "secret_id", + "description": "The ID of the secret to delete", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The ID of the secret to delete" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteUserAuthConnection.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteUserAuthConnection.json new file mode 100644 index 00000000..7cfd190b --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteUserAuthConnection.json @@ -0,0 +1,104 @@ +{ + "name": "DeleteUserAuthConnection", + "fully_qualified_name": "EngineApi.DeleteUserAuthConnection@0.1.0", + "description": "Deletes a user/auth provider connection.\n\nThis tool deletes a connection between a user and an authentication provider. It should be called when a user needs to disconnect their account from an external auth provider.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "connection_id", + "required": true, + "description": "The unique identifier for the user/auth provider connection to be deleted.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Connection ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-connections-delete'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/user_connections/{id}", + "http_method": "DELETE", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "connection_id", + "description": "Connection ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Connection ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteWorker.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteWorker.json new file mode 100644 index 00000000..dcfe9465 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/DeleteWorker.json @@ -0,0 +1,104 @@ +{ + "name": "DeleteWorker", + "fully_qualified_name": "EngineApi.DeleteWorker@0.1.0", + "description": "Deletes a specified worker from the system.\n\nUse this tool to remove a worker by providing their unique ID. It should be called when you need to permanently delete a worker record from the system.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "The unique identifier for the worker to be deleted.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-delete'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/{id}", + "http_method": "DELETE", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "Worker ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ExecuteTool.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ExecuteTool.json new file mode 100644 index 00000000..2d8d046c --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ExecuteTool.json @@ -0,0 +1,202 @@ +{ + "name": "ExecuteTool", + "fully_qualified_name": "EngineApi.ExecuteTool@0.1.0", + "description": "Execute a specified tool with given parameters.\n\nThis tool allows the execution of a specified tool by providing its name and necessary arguments. It's useful for triggering specific actions or processes as dictated by the tool's logic.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "tool_execution_request", + "required": true, + "description": "A JSON object specifying tool execution details, including tool name, input, and optional parameters like error stacktrace inclusion, run time, version, and user ID.", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "include_error_stacktrace": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Whether to include the error stacktrace in the response. If not provided, the error stacktrace is not included." + }, + "input": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "JSON input to the tool, if any" + }, + "run_at": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The time at which the tool should be run (optional). If not provided, the tool is run immediately. Format ISO 8601: YYYY-MM-DDTHH:MM:SS" + }, + "tool_name": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "tool_version": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The tool version to use (optional). If not provided, any version is used" + }, + "user_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "Tool execution request" + }, + "inferrable": true, + "http_endpoint_parameter_name": "requestBody" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tool-execute'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/tools/execute", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "requestBody", + "tool_parameter_name": "tool_execution_request", + "description": "Tool execution request", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "include_error_stacktrace": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Whether to include the error stacktrace in the response. If not provided, the error stacktrace is not included." + }, + "input": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "JSON input to the tool, if any" + }, + "run_at": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The time at which the tool should be run (optional). If not provided, the tool is run immediately. Format ISO 8601: YYYY-MM-DDTHH:MM:SS" + }, + "tool_name": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "tool_version": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The tool version to use (optional). If not provided, any version is used" + }, + "user_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "Tool execution request" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Tool execution request\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"tool_name\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"include_error_stacktrace\": {\n \"type\": \"boolean\",\n \"description\": \"Whether to include the error stacktrace in the response. If not provided, the error stacktrace is not included.\"\n },\n \"input\": {\n \"type\": \"object\",\n \"description\": \"JSON input to the tool, if any\",\n \"allOf\": [\n {\n \"type\": \"object\",\n \"additionalProperties\": true\n }\n ]\n },\n \"run_at\": {\n \"type\": \"string\",\n \"description\": \"The time at which the tool should be run (optional). If not provided, the tool is run immediately. Format ISO 8601: YYYY-MM-DDTHH:MM:SS\"\n },\n \"tool_name\": {\n \"type\": \"string\"\n },\n \"tool_version\": {\n \"type\": \"string\",\n \"description\": \"The tool version to use (optional). If not provided, any version is used\"\n },\n \"user_id\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": true, + "validate_request_body_schema": true + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/FetchToolsPage.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/FetchToolsPage.json new file mode 100644 index 00000000..053b9a74 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/FetchToolsPage.json @@ -0,0 +1,170 @@ +{ + "name": "FetchToolsPage", + "fully_qualified_name": "EngineApi.FetchToolsPage@0.1.0", + "description": "Retrieve a list of tools for a specific worker.\n\nThis tool is used to get a list of tools associated with a specific worker ID. It should be called when you need an overview of tools for a particular worker.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "The unique ID of the worker for which to retrieve the tools list.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + }, + { + "name": "number_of_items", + "required": false, + "description": "Number of items to return in the result set. Default is 25 and the maximum is 100.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "start_offset", + "required": false, + "description": "Offset from the start of the list for pagination. Defaults to 0.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tools-list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/{id}/tools", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "limit", + "tool_parameter_name": "number_of_items", + "description": "Number of items to return (default: 25, max: 100)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "start_offset", + "description": "Offset from the start of the list (default: 0)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "Worker ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetAuthProviderDetails.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetAuthProviderDetails.json new file mode 100644 index 00000000..df7e7cc5 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetAuthProviderDetails.json @@ -0,0 +1,104 @@ +{ + "name": "GetAuthProviderDetails", + "fully_qualified_name": "EngineApi.GetAuthProviderDetails@0.1.0", + "description": "Retrieve details of a specific authentication provider.\n\nUse this tool to obtain the details of a particular authentication provider by specifying its ID.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "auth_provider_id", + "required": true, + "description": "The ID of the authentication provider to retrieve.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The ID of the auth provider to get" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-providers-get'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/auth_providers/{id}", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "auth_provider_id", + "description": "The ID of the auth provider to get", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The ID of the auth provider to get" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetEngineConfiguration.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetEngineConfiguration.json new file mode 100644 index 00000000..516d75e8 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetEngineConfiguration.json @@ -0,0 +1,69 @@ +{ + "name": "GetEngineConfiguration", + "fully_qualified_name": "EngineApi.GetEngineConfiguration@0.1.0", + "description": "Fetch the current engine configuration settings.\n\nThis tool retrieves the current configuration settings for the engine. It should be called when users need to access detailed information about the engine's setup or settings.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'engine-config'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/config", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetFormattedToolSpecification.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetFormattedToolSpecification.json new file mode 100644 index 00000000..a15f126a --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetFormattedToolSpecification.json @@ -0,0 +1,170 @@ +{ + "name": "GetFormattedToolSpecification", + "fully_qualified_name": "EngineApi.GetFormattedToolSpecification@0.1.0", + "description": "Fetches a formatted specification for a given tool.\n\nUse this to obtain detailed, formatted specifications for a specific tool from a provider.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "tool_name", + "required": true, + "description": "The name of the tool for which the formatted specification is requested.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Tool name" + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "provider_format", + "required": false, + "description": "Specifies the format of the tool as required by the provider.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Provider format" + }, + "inferrable": true, + "http_endpoint_parameter_name": "format" + }, + { + "name": "user_id", + "required": false, + "description": "The identifier for the user requesting the tool specification. This should be a string.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tool-spec-formatted'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/formatted_tools/{name}", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "format", + "tool_parameter_name": "provider_format", + "description": "Provider format", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Provider format" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_id", + "description": "User ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "name", + "tool_parameter_name": "tool_name", + "description": "Tool name", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Tool name" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetModelContextProtocol.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetModelContextProtocol.json new file mode 100644 index 00000000..73c683cf --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetModelContextProtocol.json @@ -0,0 +1,69 @@ +{ + "name": "GetModelContextProtocol", + "fully_qualified_name": "EngineApi.GetModelContextProtocol@0.1.0", + "description": "Fetch data from the Model Context Protocol endpoint.\n\nThis tool calls the Model Context Protocol (MCP) endpoint using a Streamable HTTP transport method. It should be used to retrieve information related to the MCP from the specified endpoint.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'mcp-endpoint'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/mcp", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetProjectDetails.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetProjectDetails.json new file mode 100644 index 00000000..cbd29164 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetProjectDetails.json @@ -0,0 +1,137 @@ +{ + "name": "GetProjectDetails", + "fully_qualified_name": "EngineApi.GetProjectDetails@0.1.0", + "description": "Retrieve detailed information about a specific project.\n\nThis tool fetches and returns detailed information for a given project based on its ID. Use it when you need to access specific details about a project.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "project_id", + "required": true, + "description": "The unique identifier for the project to retrieve details for. This should be a string matching the project's ID in the database.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Project ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "project_id" + }, + { + "name": "authorization_token", + "required": true, + "description": "JWT token required for authentication. Should be provided in the format: 'Bearer '.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Bearer (JWT)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "Authorization" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'get-project'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/projects/{project_id}", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "project_id", + "tool_parameter_name": "project_id", + "description": "Project ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Project ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "Authorization", + "tool_parameter_name": "authorization_token", + "description": "Bearer (JWT)", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Bearer (JWT)" + }, + "accepted_as": "header", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetScheduledToolDetails.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetScheduledToolDetails.json new file mode 100644 index 00000000..c494c10c --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetScheduledToolDetails.json @@ -0,0 +1,104 @@ +{ + "name": "GetScheduledToolDetails", + "fully_qualified_name": "EngineApi.GetScheduledToolDetails@0.1.0", + "description": "Retrieve details for a specific scheduled tool execution.\n\nUse this tool to get information about a specific tool execution that has been scheduled, based on its unique identifier. It provides insights into the timing and parameters of the execution.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "scheduled_execution_id", + "required": true, + "description": "The unique identifier for the scheduled tool execution to retrieve details for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Scheduled execution ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tool-scheduled-get'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/scheduled_tools/{id}", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "scheduled_execution_id", + "description": "Scheduled execution ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Scheduled execution ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetScheduledToolExecutions.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetScheduledToolExecutions.json new file mode 100644 index 00000000..69fc4872 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetScheduledToolExecutions.json @@ -0,0 +1,137 @@ +{ + "name": "GetScheduledToolExecutions", + "fully_qualified_name": "EngineApi.GetScheduledToolExecutions@0.1.0", + "description": "Fetch a list of scheduled tool executions.\n\nUse this tool to retrieve a page of scheduled tool executions, useful for monitoring upcoming automated processes.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "items_limit", + "required": false, + "description": "The number of scheduled tool executions to return. Defaults to 25, max is 100.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "list_offset", + "required": false, + "description": "The starting position in the list of scheduled tool executions, default is 0.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tool-scheduled-list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/scheduled_tools", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "limit", + "tool_parameter_name": "items_limit", + "description": "Number of items to return (default: 25, max: 100)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "list_offset", + "description": "Offset from the start of the list (default: 0)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetSessionVerificationSettings.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetSessionVerificationSettings.json new file mode 100644 index 00000000..16114edc --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetSessionVerificationSettings.json @@ -0,0 +1,69 @@ +{ + "name": "GetSessionVerificationSettings", + "fully_qualified_name": "EngineApi.GetSessionVerificationSettings@0.1.0", + "description": "Retrieve current session verification settings.\n\nUse this tool to obtain the latest session verification settings for your account or application. It's helpful for understanding the security measures currently in place for session verification.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'session-verification-settings-get'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/settings/session_verification", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetSwaggerSpecification.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetSwaggerSpecification.json new file mode 100644 index 00000000..e71df480 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetSwaggerSpecification.json @@ -0,0 +1,69 @@ +{ + "name": "GetSwaggerSpecification", + "fully_qualified_name": "EngineApi.GetSwaggerSpecification@0.1.0", + "description": "Retrieve the Swagger JSON specification for the API.\n\nUse this tool to access the Swagger JSON specification, which provides detailed information about the API's available endpoints and their usage.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'swagger'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/swagger", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetToolSpecification.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetToolSpecification.json new file mode 100644 index 00000000..c46b7c52 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetToolSpecification.json @@ -0,0 +1,170 @@ +{ + "name": "GetToolSpecification", + "fully_qualified_name": "EngineApi.GetToolSpecification@0.1.0", + "description": "Retrieve the specification for a specific arcade tool.\n\nThis tool returns the arcade tool specification for a specified tool by its name. It should be called when there's a need to understand the details or capabilities of a particular tool.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "tool_name", + "required": true, + "description": "The name of the tool whose specification is to be retrieved. This should match the tool's registered name.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Tool name" + }, + "inferrable": true, + "http_endpoint_parameter_name": "name" + }, + { + "name": "formats_to_include", + "required": false, + "description": "List of tool formats to include in the response. Provide formats as a list of strings.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Comma separated tool formats that will be included in the response." + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_format" + }, + { + "name": "user_identifier", + "required": false, + "description": "The unique identifier for the user requesting the tool specification.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tool-spec'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/tools/{name}", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "include_format", + "tool_parameter_name": "formats_to_include", + "description": "Comma separated tool formats that will be included in the response.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Comma separated tool formats that will be included in the response." + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_identifier", + "description": "User ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "name", + "tool_parameter_name": "tool_name", + "description": "Tool name", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Tool name" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetToolsList.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetToolsList.json new file mode 100644 index 00000000..5cd2df6b --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetToolsList.json @@ -0,0 +1,236 @@ +{ + "name": "GetToolsList", + "fully_qualified_name": "EngineApi.GetToolsList@0.1.0", + "description": "Retrieve a list of tools from the engine configuration.\n\nUse this tool to get a paginated list of tools available in the engine configuration, with optional filtering by toolkit.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "toolkit_name", + "required": false, + "description": "Specifies the name of the toolkit to filter the tools list.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Toolkit name" + }, + "inferrable": true, + "http_endpoint_parameter_name": "toolkit" + }, + { + "name": "items_per_page", + "required": false, + "description": "Specify the number of tools to return, with a maximum of 100. Defaults to 25 if not specified.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "start_offset", + "required": false, + "description": "Offset to determine the starting point from the list of tools. Default is 0.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + }, + { + "name": "include_formats", + "required": false, + "description": "List of tool formats to include in the response, specified by their names.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Comma separated tool formats that will be included in the response." + }, + "inferrable": true, + "http_endpoint_parameter_name": "include_format" + }, + { + "name": "user_id", + "required": false, + "description": "The ID of the user requesting the tool list. It is used to filter the results for a specific user context.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tools-list-static'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/tools", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "toolkit", + "tool_parameter_name": "toolkit_name", + "description": "Toolkit name", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Toolkit name" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "items_per_page", + "description": "Number of items to return (default: 25, max: 100)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "start_offset", + "description": "Offset from the start of the list (default: 0)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "include_format", + "tool_parameter_name": "include_formats", + "description": "Comma separated tool formats that will be included in the response.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Comma separated tool formats that will be included in the response." + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_id", + "description": "User ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetWorkerById.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetWorkerById.json new file mode 100644 index 00000000..37928aab --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetWorkerById.json @@ -0,0 +1,104 @@ +{ + "name": "GetWorkerById", + "fully_qualified_name": "EngineApi.GetWorkerById@0.1.0", + "description": "Retrieve worker details using their ID.\n\nUse this tool to obtain detailed information about a worker by providing their unique ID. Ideal for situations where specific worker data is required.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "The unique identifier for the worker to retrieve details.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-get'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/{id}", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "Worker ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetWorkerHealthStatus.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetWorkerHealthStatus.json new file mode 100644 index 00000000..319d9d05 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/GetWorkerHealthStatus.json @@ -0,0 +1,104 @@ +{ + "name": "GetWorkerHealthStatus", + "fully_qualified_name": "EngineApi.GetWorkerHealthStatus@0.1.0", + "description": "Retrieve the health status of a worker.\n\nThis tool is used to check the health status of a specific worker by their ID. It should be called when you need to monitor or verify the operational status of a worker.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "The unique identifier for the worker whose health status you want to check.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-health'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/{id}/health", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "Worker ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAccessibleProjects.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAccessibleProjects.json new file mode 100644 index 00000000..a06795d5 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAccessibleProjects.json @@ -0,0 +1,170 @@ +{ + "name": "ListAccessibleProjects", + "fully_qualified_name": "EngineApi.ListAccessibleProjects@0.1.0", + "description": "Retrieve a list of accessible projects.\n\nThis tool returns all projects that the caller has access to. It is useful for identifying projects available to a specific user or account.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "bearer_token", + "required": true, + "description": "A string containing the Bearer (JWT) token for authentication.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Bearer (JWT)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "Authorization" + }, + { + "name": "maximum_items_to_return", + "required": false, + "description": "Specifies the maximum number of projects to return. Must be an integer.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Maximum number of items to return" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "items_to_skip", + "required": false, + "description": "The number of projects to skip before starting to collect the result set.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to skip" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'list-projects'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/projects", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "limit", + "tool_parameter_name": "maximum_items_to_return", + "description": "Maximum number of items to return", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Maximum number of items to return" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": 25, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "items_to_skip", + "description": "Number of items to skip", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to skip" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": 0, + "documentation_urls": [] + }, + { + "name": "Authorization", + "tool_parameter_name": "bearer_token", + "description": "Bearer (JWT)", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Bearer (JWT)" + }, + "accepted_as": "header", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAuthConnections.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAuthConnections.json new file mode 100644 index 00000000..6adb4566 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAuthConnections.json @@ -0,0 +1,203 @@ +{ + "name": "ListAuthConnections", + "fully_qualified_name": "EngineApi.ListAuthConnections@0.1.0", + "description": "Retrieve all authentication connections for users.\n\nUse this tool to get a comprehensive list of all authentication connections associated with users. Ideal for managing or auditing user authentication setups.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "provider_id", + "required": false, + "description": "Unique identifier for the authentication provider.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Provider ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "provider.id" + }, + { + "name": "user_id", + "required": false, + "description": "The unique identifier for the user to list authentication connections for.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user.id" + }, + { + "name": "page_size", + "required": false, + "description": "Number of auth connections to return per page. Use to control the size of the result set.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Page size" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "page_offset", + "required": false, + "description": "The starting point in the list for pagination. Useful for retrieving subsequent pages of data.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Page offset" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-connections-list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/user_connections", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "provider.id", + "tool_parameter_name": "provider_id", + "description": "Provider ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Provider ID" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user.id", + "tool_parameter_name": "user_id", + "description": "User ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "page_size", + "description": "Page size", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Page size" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "page_offset", + "description": "Page offset", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Page offset" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAvailableAuthProviders.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAvailableAuthProviders.json new file mode 100644 index 00000000..d1044024 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListAvailableAuthProviders.json @@ -0,0 +1,69 @@ +{ + "name": "ListAvailableAuthProviders", + "fully_qualified_name": "EngineApi.ListAvailableAuthProviders@0.1.0", + "description": "Retrieve a list of available authentication providers.\n\nThis tool fetches a paginated list of authentication providers accessible to the caller. It should be used when identifying or managing auth providers in the system.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'auth-providers-list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/auth_providers", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListVisibleSecrets.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListVisibleSecrets.json new file mode 100644 index 00000000..872ec0e0 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListVisibleSecrets.json @@ -0,0 +1,69 @@ +{ + "name": "ListVisibleSecrets", + "fully_qualified_name": "EngineApi.ListVisibleSecrets@0.1.0", + "description": "Retrieve all secrets visible to the caller.\n\nThis tool fetches a list of all secrets that the caller has access to. It should be used when there is a need to view available secrets within the user's administrative scope.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'secrets-list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/secrets", + "http_method": "GET", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListWorkers.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListWorkers.json new file mode 100644 index 00000000..905dd57a --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ListWorkers.json @@ -0,0 +1,137 @@ +{ + "name": "ListWorkers", + "fully_qualified_name": "EngineApi.ListWorkers@0.1.0", + "description": "Retrieve a list of all workers with their definitions.\n\nUse this tool to get information about all available workers and their definitions. This can be helpful for managing or reviewing the current worker pool.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "number_of_items_to_return", + "required": false, + "description": "The maximum number of worker items to return, with a default of 25 and a maximum of 100.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "start_offset", + "required": false, + "description": "Offset from the start of the list for pagination. Defaults to 0.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-list'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "limit", + "tool_parameter_name": "number_of_items_to_return", + "description": "Number of items to return (default: 25, max: 100)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "start_offset", + "description": "Offset from the start of the list (default: 0)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ManageSecret.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ManageSecret.json new file mode 100644 index 00000000..b4d62c23 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ManageSecret.json @@ -0,0 +1,170 @@ +{ + "name": "ManageSecret", + "fully_qualified_name": "EngineApi.ManageSecret@0.1.0", + "description": "Create or update a stored secret key-value pair.\n\nUse this tool to create a new secret or update an existing secret in the storage system. It should be called when secret management tasks are needed, such as adding new credentials or modifying existing ones.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "secret_key", + "required": true, + "description": "The key of the secret to be created or updated in the storage system. It should be a unique identifier for the secret.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The key of the secret to upsert" + }, + "inferrable": true, + "http_endpoint_parameter_name": "secret_key" + }, + { + "name": "secret_value", + "required": true, + "description": "The new or updated value of the secret to be stored. It should be a string containing the secret information.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "value" + }, + { + "name": "secret_description", + "required": false, + "description": "A description of the secret. Provide details about the secret's purpose or context.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "description" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'secrets-upsert'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/secrets/{secret_key}", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "secret_key", + "tool_parameter_name": "secret_key", + "description": "The key of the secret to upsert", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The key of the secret to upsert" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "description", + "tool_parameter_name": "secret_description", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "value", + "tool_parameter_name": "secret_value", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"The secret to upsert\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"value\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"description\": {\n \"type\": \"string\"\n },\n \"value\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ModelContextProtocolStream.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ModelContextProtocolStream.json new file mode 100644 index 00000000..97a5265f --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/ModelContextProtocolStream.json @@ -0,0 +1,69 @@ +{ + "name": "ModelContextProtocolStream", + "fully_qualified_name": "EngineApi.ModelContextProtocolStream@0.1.0", + "description": "Access the Model Context Protocol for streaming data.\n\nThis tool interacts with the Model Context Protocol endpoint using a streamable HTTP transport, allowing for real-time data communication. It's useful for scenarios where ongoing data exchange is necessary.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [] + }, + "output": { + "description": "Response from the API endpoint 'mcp-endpoint'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/mcp", + "http_method": "POST", + "headers": {}, + "parameters": [], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/OpenaiChatInteraction.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/OpenaiChatInteraction.json new file mode 100644 index 00000000..b8d3710f --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/OpenaiChatInteraction.json @@ -0,0 +1,620 @@ +{ + "name": "OpenaiChatInteraction", + "fully_qualified_name": "EngineApi.OpenaiChatInteraction@0.1.0", + "description": "Engage with language models using OpenAI's chat API.\n\nUse this tool to interact with language models via OpenAI's chat completions API, suitable for generating conversation responses.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "openai_chat_request_data", + "required": true, + "description": "Payload containing parameters such as messages, model, temperature, and others for the chat interaction.", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "frequency_penalty": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "logit_bias": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "LogitBias is must be a token id string (specified by their token ID in the tokenizer), not a word string.\nincorrect: `\"logit_bias\":{\"You\": 6}`, correct: `\"logit_bias\":{\"1639\": 6}`\nrefs: https://platform.openai.com/docs/api-reference/chat/create#chat/create-logit_bias" + }, + "logprobs": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "LogProbs indicates whether to return log probabilities of the output tokens or not.\nIf true, returns the log probabilities of each output token returned in the content of message.\nThis option is currently not available on the gpt-4-vision-preview model." + }, + "max_tokens": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "messages": { + "val_type": "array", + "inner_val_type": "json", + "enum": null, + "properties": null, + "inner_properties": { + "content": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The content of the message." + }, + "name": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "tool Name" + }, + "role": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The role of the author of this message. One of system, user, tool, or assistant." + }, + "tool_call_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "tool_call_id" + }, + "tool_calls": { + "val_type": "array", + "inner_val_type": "json", + "enum": null, + "properties": null, + "inner_properties": { + "function": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "arguments": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "name": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "function" + ], + "properties": null, + "inner_properties": null, + "description": null + } + }, + "description": "tool calls if any" + } + }, + "description": null + }, + "model": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "n": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "parallel_tool_calls": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Disable the default behavior of parallel tool calls by setting it: false." + }, + "presence_penalty": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "response_format": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "json_object", + "text" + ], + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "seed": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "stop": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "stream": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "stream_options": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Options for streaming response. Only set this when you set stream: true." + }, + "temperature": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "tool_choice": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "This can be either a string or an ToolChoice object." + }, + "tools": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "top_logprobs": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "TopLogProbs is an integer between 0 and 5 specifying the number of most likely tokens to return at each\ntoken position, each with an associated log probability.\nlogprobs must be set to true if this parameter is used." + }, + "top_p": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "user": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "Request Data" + }, + "inferrable": true, + "http_endpoint_parameter_name": "requestBody" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'llm-chat'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/chat/completions", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "requestBody", + "tool_parameter_name": "openai_chat_request_data", + "description": "Request Data", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "frequency_penalty": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "logit_bias": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "LogitBias is must be a token id string (specified by their token ID in the tokenizer), not a word string.\nincorrect: `\"logit_bias\":{\"You\": 6}`, correct: `\"logit_bias\":{\"1639\": 6}`\nrefs: https://platform.openai.com/docs/api-reference/chat/create#chat/create-logit_bias" + }, + "logprobs": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "LogProbs indicates whether to return log probabilities of the output tokens or not.\nIf true, returns the log probabilities of each output token returned in the content of message.\nThis option is currently not available on the gpt-4-vision-preview model." + }, + "max_tokens": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "messages": { + "val_type": "array", + "inner_val_type": "json", + "enum": null, + "properties": null, + "inner_properties": { + "content": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The content of the message." + }, + "name": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "tool Name" + }, + "role": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "The role of the author of this message. One of system, user, tool, or assistant." + }, + "tool_call_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "tool_call_id" + }, + "tool_calls": { + "val_type": "array", + "inner_val_type": "json", + "enum": null, + "properties": null, + "inner_properties": { + "function": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "arguments": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "name": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "function" + ], + "properties": null, + "inner_properties": null, + "description": null + } + }, + "description": "tool calls if any" + } + }, + "description": null + }, + "model": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "n": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "parallel_tool_calls": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Disable the default behavior of parallel tool calls by setting it: false." + }, + "presence_penalty": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "response_format": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "json_object", + "text" + ], + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "seed": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "stop": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "stream": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "stream_options": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Options for streaming response. Only set this when you set stream: true." + }, + "temperature": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "tool_choice": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "This can be either a string or an ToolChoice object." + }, + "tools": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "top_logprobs": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "TopLogProbs is an integer between 0 and 5 specifying the number of most likely tokens to return at each\ntoken position, each with an associated log probability.\nlogprobs must be set to true if this parameter is used." + }, + "top_p": { + "val_type": "number", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "user": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "Request Data" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Request Data\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"type\": \"object\",\n \"properties\": {\n \"frequency_penalty\": {\n \"type\": \"number\"\n },\n \"logit_bias\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"integer\"\n },\n \"description\": \"LogitBias is must be a token id string (specified by their token ID in the tokenizer), not a word string.\\nincorrect: `\\\"logit_bias\\\":{\\\"You\\\": 6}`, correct: `\\\"logit_bias\\\":{\\\"1639\\\": 6}`\\nrefs: https://platform.openai.com/docs/api-reference/chat/create#chat/create-logit_bias\"\n },\n \"logprobs\": {\n \"type\": \"boolean\",\n \"description\": \"LogProbs indicates whether to return log probabilities of the output tokens or not.\\nIf true, returns the log probabilities of each output token returned in the content of message.\\nThis option is currently not available on the gpt-4-vision-preview model.\"\n },\n \"max_tokens\": {\n \"type\": \"integer\"\n },\n \"messages\": {\n \"type\": \"array\",\n \"items\": {\n \"required\": [\n \"content\",\n \"role\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"content\": {\n \"type\": \"string\",\n \"description\": \"The content of the message.\"\n },\n \"name\": {\n \"type\": \"string\",\n \"description\": \"tool Name\"\n },\n \"role\": {\n \"type\": \"string\",\n \"description\": \"The role of the author of this message. One of system, user, tool, or assistant.\"\n },\n \"tool_call_id\": {\n \"type\": \"string\",\n \"description\": \"tool_call_id\"\n },\n \"tool_calls\": {\n \"type\": \"array\",\n \"description\": \"tool calls if any\",\n \"items\": {\n \"type\": \"object\",\n \"properties\": {\n \"function\": {\n \"type\": \"object\",\n \"properties\": {\n \"arguments\": {\n \"type\": \"string\"\n },\n \"name\": {\n \"type\": \"string\"\n }\n }\n },\n \"id\": {\n \"type\": \"string\"\n },\n \"type\": {\n \"type\": \"string\",\n \"enum\": [\n \"function\"\n ],\n \"x-enum-varnames\": [\n \"ToolTypeFunction\"\n ]\n }\n }\n }\n }\n }\n }\n },\n \"model\": {\n \"type\": \"string\"\n },\n \"n\": {\n \"type\": \"integer\"\n },\n \"parallel_tool_calls\": {\n \"type\": \"boolean\",\n \"description\": \"Disable the default behavior of parallel tool calls by setting it: false.\"\n },\n \"presence_penalty\": {\n \"type\": \"number\"\n },\n \"response_format\": {\n \"type\": \"object\",\n \"properties\": {\n \"type\": {\n \"type\": \"string\",\n \"enum\": [\n \"json_object\",\n \"text\"\n ],\n \"x-enum-varnames\": [\n \"ResponseFormatJSON\",\n \"ResponseFormatText\"\n ]\n }\n }\n },\n \"seed\": {\n \"type\": \"integer\"\n },\n \"stop\": {\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n },\n \"stream\": {\n \"type\": \"boolean\"\n },\n \"stream_options\": {\n \"type\": \"object\",\n \"description\": \"Options for streaming response. Only set this when you set stream: true.\",\n \"allOf\": [\n {\n \"type\": \"object\",\n \"properties\": {\n \"include_usage\": {\n \"type\": \"boolean\",\n \"description\": \"If set, an additional chunk will be streamed before the data: [DONE] message.\\nThe usage field on this chunk shows the token usage statistics for the entire request,\\nand the choices field will always be an empty array.\\nAll other chunks will also include a usage field, but with a null value.\"\n }\n }\n }\n ]\n },\n \"temperature\": {\n \"type\": \"number\"\n },\n \"tool_choice\": {\n \"type\": \"object\",\n \"description\": \"This can be either a string or an ToolChoice object.\"\n },\n \"tools\": {\n \"type\": \"object\"\n },\n \"top_logprobs\": {\n \"type\": \"integer\",\n \"description\": \"TopLogProbs is an integer between 0 and 5 specifying the number of most likely tokens to return at each\\ntoken position, each with an associated log probability.\\nlogprobs must be set to true if this parameter is used.\"\n },\n \"top_p\": {\n \"type\": \"number\"\n },\n \"user\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": true, + "validate_request_body_schema": true + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/RetrieveFormattedToolsList.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/RetrieveFormattedToolsList.json new file mode 100644 index 00000000..0877045d --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/RetrieveFormattedToolsList.json @@ -0,0 +1,236 @@ +{ + "name": "RetrieveFormattedToolsList", + "fully_qualified_name": "EngineApi.RetrieveFormattedToolsList@0.1.0", + "description": "Fetches a formatted list of tools from engine configuration.\n\nUse this tool to retrieve a page of tools from the engine's configuration, which can be filtered by toolkit and formatted for a specific provider.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "filter_by_toolkit", + "required": false, + "description": "Specify the toolkit name to filter the list of tools.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Toolkit name" + }, + "inferrable": true, + "http_endpoint_parameter_name": "toolkit" + }, + { + "name": "number_of_items_to_return", + "required": false, + "description": "Specify the number of tools to return. Defaults to 25, with a maximum of 100.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "limit" + }, + { + "name": "offset_start_index", + "required": false, + "description": "Offset from the start of the tools list. Default is 0.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "inferrable": true, + "http_endpoint_parameter_name": "offset" + }, + { + "name": "provider_format", + "required": false, + "description": "Format the tools according to the provider's specifications. Accepts a string value.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Provider format" + }, + "inferrable": true, + "http_endpoint_parameter_name": "format" + }, + { + "name": "user_identifier", + "required": false, + "description": "The ID of the user for whom the tool list is to be retrieved.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'tools-list-formatted'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/formatted_tools", + "http_method": "GET", + "headers": {}, + "parameters": [ + { + "name": "toolkit", + "tool_parameter_name": "filter_by_toolkit", + "description": "Toolkit name", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Toolkit name" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "limit", + "tool_parameter_name": "number_of_items_to_return", + "description": "Number of items to return (default: 25, max: 100)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Number of items to return (default: 25, max: 100)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "offset", + "tool_parameter_name": "offset_start_index", + "description": "Offset from the start of the list (default: 0)", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Offset from the start of the list (default: 0)" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "format", + "tool_parameter_name": "provider_format", + "description": "Provider format", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Provider format" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_identifier", + "description": "User ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "User ID" + }, + "accepted_as": "query", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": null, + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/StartAuthorizationProcess.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/StartAuthorizationProcess.json new file mode 100644 index 00000000..7546fb84 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/StartAuthorizationProcess.json @@ -0,0 +1,269 @@ +{ + "name": "StartAuthorizationProcess", + "fully_qualified_name": "EngineApi.StartAuthorizationProcess@0.1.0", + "description": "Starts the authorization process for given requirements.\n\nUse this tool to initiate the authorization process based on specified requirements. Ideal for cases where user authentication needs to be initiated or validated.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "user_id", + "required": true, + "description": "Unique identifier for the user. Required to start the authorization process.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "user_id" + }, + { + "name": "authorization_requirement_id", + "required": false, + "description": "Set this ID for initiating authorization. Either this ID or the provider ID must be set.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "one of ID or ProviderID must be set" + }, + "inferrable": true, + "http_endpoint_parameter_name": "auth_requirement.id" + }, + { + "name": "oauth2_scopes", + "required": false, + "description": "A list of OAuth2 scopes that specify the level of access required for the authorization. Each scope should be provided as a string.", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "auth_requirement.oauth2.scopes" + }, + { + "name": "authorization_provider_id", + "required": false, + "description": "The provider ID for authorization. One of ID or ProviderID must be set.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "one of ID or ProviderID must be set" + }, + "inferrable": true, + "http_endpoint_parameter_name": "auth_requirement.provider_id" + }, + { + "name": "authorization_provider_type", + "required": false, + "description": "Specifies the type of authorization provider to be used, such as 'OAuth2', 'SAML', etc.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "auth_requirement.provider_type" + }, + { + "name": "redirection_uri_after_authorization", + "required": false, + "description": "Optional URI to redirect the user after authorization. If provided, the user will be redirected to this specific address once the authorization process is complete.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Optional: if provided, the user will be redirected to this URI after authorization" + }, + "inferrable": true, + "http_endpoint_parameter_name": "next_uri" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'initiate-authorization'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/auth/authorize", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "auth_requirement.id", + "tool_parameter_name": "authorization_requirement_id", + "description": "one of ID or ProviderID must be set", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "one of ID or ProviderID must be set" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "auth_requirement.oauth2.scopes", + "tool_parameter_name": "oauth2_scopes", + "description": "", + "value_schema": { + "val_type": "array", + "inner_val_type": "string", + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "auth_requirement.provider_id", + "tool_parameter_name": "authorization_provider_id", + "description": "one of ID or ProviderID must be set", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "one of ID or ProviderID must be set" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "auth_requirement.provider_type", + "tool_parameter_name": "authorization_provider_type", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "next_uri", + "tool_parameter_name": "redirection_uri_after_authorization", + "description": "Optional: if provided, the user will be redirected to this URI after authorization", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Optional: if provided, the user will be redirected to this URI after authorization" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "user_id", + "tool_parameter_name": "user_id", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Authorization request\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"auth_requirement\",\n \"user_id\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"auth_requirement\": {\n \"type\": \"object\",\n \"properties\": {\n \"id\": {\n \"type\": \"string\",\n \"description\": \"one of ID or ProviderID must be set\"\n },\n \"oauth2\": {\n \"type\": \"object\",\n \"properties\": {\n \"scopes\": {\n \"type\": \"array\",\n \"items\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"provider_id\": {\n \"type\": \"string\",\n \"description\": \"one of ID or ProviderID must be set\"\n },\n \"provider_type\": {\n \"type\": \"string\"\n }\n }\n },\n \"next_uri\": {\n \"type\": \"string\",\n \"description\": \"Optional: if provided, the user will be redirected to this URI after authorization\"\n },\n \"user_id\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/TestWorkerConnection.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/TestWorkerConnection.json new file mode 100644 index 00000000..1f75173e --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/TestWorkerConnection.json @@ -0,0 +1,170 @@ +{ + "name": "TestWorkerConnection", + "fully_qualified_name": "EngineApi.TestWorkerConnection@0.1.0", + "description": "Test a worker connection before adding it to the system.\n\nUse this tool to verify if a worker connection is functioning properly before integrating it into your system.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_connection_type", + "required": true, + "description": "Specify the type of worker connection to test. It must be a string value indicating the category or mode of the worker.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "type" + }, + { + "name": "http_uri", + "required": false, + "description": "Specify the HTTP URI of the worker to test the connection.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.uri" + }, + { + "name": "mcp_uri", + "required": false, + "description": "The URI for the MCP connection required to test a worker connection.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.uri" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-test'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/test", + "http_method": "POST", + "headers": {}, + "parameters": [ + { + "name": "http.uri", + "tool_parameter_name": "http_uri", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.uri", + "tool_parameter_name": "mcp_uri", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "type", + "tool_parameter_name": "worker_connection_type", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Minimal worker configuration to test\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"required\": [\n \"type\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"http\": {\n \"required\": [\n \"uri\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"uri\": {\n \"maxLength\": 256,\n \"type\": \"string\"\n }\n }\n },\n \"mcp\": {\n \"required\": [\n \"uri\"\n ],\n \"type\": \"object\",\n \"properties\": {\n \"uri\": {\n \"maxLength\": 256,\n \"type\": \"string\"\n }\n }\n },\n \"type\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateAuthProvider.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateAuthProvider.json new file mode 100644 index 00000000..0b119a91 --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateAuthProvider.json @@ -0,0 +1,926 @@ +{ + "name": "UpdateAuthProvider", + "fully_qualified_name": "EngineApi.UpdateAuthProvider@0.1.0", + "description": "Update an existing authentication provider.\n\nUse this tool to patch details of an existing authentication provider by providing its ID. This is useful when changes are needed in the authentication configuration.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "auth_provider_details", + "required": true, + "description": "JSON containing the auth provider details to update, including ID, description, OAuth2 settings, and more.", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "description": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "oauth2": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "authorize_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "client_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "client_secret": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "pkce": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "code_challenge_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "enabled": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "refresh_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "scope_delimiter": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + ",", + " " + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "token_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "user_info_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "triggers": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "on_token_grant": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "on_token_refresh": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "provider_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "status": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "The auth provider to update" + }, + "inferrable": true, + "http_endpoint_parameter_name": "requestBody" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'auth-providers-update'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/auth_providers/{id}", + "http_method": "PATCH", + "headers": {}, + "parameters": [ + { + "name": "requestBody", + "tool_parameter_name": "auth_provider_details", + "description": "The auth provider to update", + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "description": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "oauth2": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "authorize_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "client_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "client_secret": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "pkce": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "code_challenge_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "enabled": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "refresh_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "scope_delimiter": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + ",", + " " + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "token_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "user_info_request": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "auth_method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "endpoint": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "method": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "params": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "request_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_content_type": { + "val_type": "string", + "inner_val_type": null, + "enum": [ + "application/x-www-form-urlencoded", + "application/json" + ], + "properties": null, + "inner_properties": null, + "description": null + }, + "response_map": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "triggers": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": { + "on_token_grant": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "on_token_refresh": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": null + }, + "provider_id": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "status": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + }, + "type": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "inner_properties": null, + "description": "The auth provider to update" + }, + "accepted_as": "body", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"The auth provider to update\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"type\": \"object\",\n \"properties\": {\n \"description\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"id\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n },\n \"oauth2\": {\n \"type\": \"object\",\n \"properties\": {\n \"authorize_request\": {\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"client_id\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"client_secret\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"pkce\": {\n \"type\": \"object\",\n \"properties\": {\n \"code_challenge_method\": {\n \"type\": \"string\"\n },\n \"enabled\": {\n \"type\": \"boolean\"\n }\n }\n },\n \"refresh_request\": {\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"scope_delimiter\": {\n \"type\": \"string\",\n \"enum\": [\n \",\",\n \" \"\n ]\n },\n \"token_request\": {\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n }\n }\n },\n \"user_info_request\": {\n \"type\": \"object\",\n \"properties\": {\n \"auth_method\": {\n \"type\": \"string\"\n },\n \"endpoint\": {\n \"maxLength\": 1000,\n \"type\": \"string\"\n },\n \"method\": {\n \"type\": \"string\"\n },\n \"params\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"request_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_content_type\": {\n \"type\": \"string\",\n \"enum\": [\n \"application/x-www-form-urlencoded\",\n \"application/json\"\n ]\n },\n \"response_map\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"type\": \"string\"\n }\n },\n \"triggers\": {\n \"type\": \"object\",\n \"properties\": {\n \"on_token_grant\": {\n \"type\": \"boolean\"\n },\n \"on_token_refresh\": {\n \"type\": \"boolean\"\n }\n }\n }\n }\n }\n }\n },\n \"provider_id\": {\n \"type\": \"string\"\n },\n \"status\": {\n \"type\": \"string\"\n },\n \"type\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": true, + "validate_request_body_schema": true + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateSessionVerificationSettings.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateSessionVerificationSettings.json new file mode 100644 index 00000000..b382a3aa --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateSessionVerificationSettings.json @@ -0,0 +1,137 @@ +{ + "name": "UpdateSessionVerificationSettings", + "fully_qualified_name": "EngineApi.UpdateSessionVerificationSettings@0.1.0", + "description": "Update session verification settings for a user.\n\nThis tool updates the session verification settings for the user or entity making the call. It should be used when there's a need to modify how sessions are verified, reflecting any new security or configuration preferences.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "verifier_url", + "required": false, + "description": "The URL of the verifier service used for session verification. Provide a valid URL.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "verifier_url" + }, + { + "name": "unsafe_skip_verification", + "required": false, + "description": "Set to true to skip the session verification, making it unsafe.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "unsafe_skip_verification" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'session-verification-settings-update'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/admin/settings/session_verification", + "http_method": "PUT", + "headers": {}, + "parameters": [ + { + "name": "unsafe_skip_verification", + "tool_parameter_name": "unsafe_skip_verification", + "description": "", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "verifier_url", + "tool_parameter_name": "verifier_url", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"The settings to update\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"type\": \"object\",\n \"properties\": {\n \"unsafe_skip_verification\": {\n \"type\": \"boolean\"\n },\n \"verifier_url\": {\n \"type\": \"string\"\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateWorkerDetails.json b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateWorkerDetails.json new file mode 100644 index 00000000..781846de --- /dev/null +++ b/toolkits/arcade_engine_api/arcade_engine_api/wrapper_tools/UpdateWorkerDetails.json @@ -0,0 +1,368 @@ +{ + "name": "UpdateWorkerDetails", + "fully_qualified_name": "EngineApi.UpdateWorkerDetails@0.1.0", + "description": "Update or modify details of a specific worker.\n\nUse this tool to update the information of a worker by specifying their unique ID. Ideal for scenarios where worker data needs modification or correction.", + "toolkit": { + "name": "ArcadeEngineApi", + "description": null, + "version": "0.1.0" + }, + "input": { + "parameters": [ + { + "name": "worker_id", + "required": true, + "description": "Unique identifier for the worker to be updated.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "inferrable": true, + "http_endpoint_parameter_name": "id" + }, + { + "name": "http_retry_attempts", + "required": false, + "description": "Specify the number of retry attempts for HTTP requests.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.retry" + }, + { + "name": "http_webhook_secret", + "required": false, + "description": "The secret key for authenticating HTTP webhook requests. It should be a secure string shared between sender and receiver.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.secret" + }, + { + "name": "http_timeout_duration", + "required": false, + "description": "The duration in seconds for the HTTP request timeout for updating a worker. Use an integer to specify the time limit.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.timeout" + }, + { + "name": "worker_http_uri", + "required": false, + "description": "The HTTP URI for the worker's endpoint. Provide a valid URI string.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "http.uri" + }, + { + "name": "mcp_retry_attempts", + "required": false, + "description": "Set the number of retry attempts for the MCP connection during update.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.retry" + }, + { + "name": "mcp_timeout_duration", + "required": false, + "description": "Set the MCP request timeout duration in seconds. Expect an integer value.", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.timeout" + }, + { + "name": "mcp_uri", + "required": false, + "description": "The URI for the MCP (Message Control Protocol) endpoint to interact with the worker's messaging system.", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "mcp.uri" + }, + { + "name": "enable_worker", + "required": false, + "description": "Set to 'true' to enable the worker or 'false' to disable it.", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "inferrable": true, + "http_endpoint_parameter_name": "enabled" + } + ] + }, + "output": { + "description": "Response from the API endpoint 'workers-update'.", + "available_modes": [ + "value", + "error", + "null" + ], + "value_schema": { + "val_type": "json", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": null + } + }, + "requirements": { + "authorization": null, + "secrets": [ + { + "key": "ARCADE_API_KEY" + } + ], + "metadata": null + }, + "deprecation_message": null, + "metadata": { + "object_type": "api_wrapper_tool", + "version": "1.1.0", + "description": "Tools that enable LLMs to interact directly with the engine API." + }, + "http_endpoint": { + "metadata": { + "object_type": "http_endpoint", + "version": "1.2.0", + "description": "" + }, + "url": "https://api.arcade.dev/v1/workers/{id}", + "http_method": "PATCH", + "headers": {}, + "parameters": [ + { + "name": "id", + "tool_parameter_name": "worker_id", + "description": "Worker ID", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "Worker ID" + }, + "accepted_as": "path", + "required": true, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "enabled", + "tool_parameter_name": "enable_worker", + "description": "", + "value_schema": { + "val_type": "boolean", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.retry", + "tool_parameter_name": "http_retry_attempts", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.secret", + "tool_parameter_name": "http_webhook_secret", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.timeout", + "tool_parameter_name": "http_timeout_duration", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "http.uri", + "tool_parameter_name": "worker_http_uri", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.retry", + "tool_parameter_name": "mcp_retry_attempts", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.timeout", + "tool_parameter_name": "mcp_timeout_duration", + "description": "", + "value_schema": { + "val_type": "integer", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + }, + { + "name": "mcp.uri", + "tool_parameter_name": "mcp_uri", + "description": "", + "value_schema": { + "val_type": "string", + "inner_val_type": null, + "enum": null, + "properties": null, + "inner_properties": null, + "description": "" + }, + "accepted_as": "body", + "required": false, + "deprecated": false, + "default": null, + "documentation_urls": [] + } + ], + "documentation_urls": [], + "secrets": [ + { + "arcade_key": "ARCADE_API_KEY", + "parameter_name": "Authorization", + "accepted_as": "header", + "formatted_value": null, + "description": "", + "is_auth_token": false + } + ], + "request_body_spec": "{\n \"description\": \"Worker configuration to update\",\n \"content\": {\n \"application/json\": {\n \"schema\": {\n \"type\": \"object\",\n \"properties\": {\n \"enabled\": {\n \"type\": \"boolean\"\n },\n \"http\": {\n \"type\": \"object\",\n \"properties\": {\n \"retry\": {\n \"maximum\": 10,\n \"minimum\": 0,\n \"type\": \"integer\"\n },\n \"secret\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n },\n \"timeout\": {\n \"maximum\": 4000,\n \"minimum\": 1,\n \"type\": \"integer\"\n },\n \"uri\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n }\n }\n },\n \"mcp\": {\n \"type\": \"object\",\n \"properties\": {\n \"retry\": {\n \"maximum\": 10,\n \"minimum\": 0,\n \"type\": \"integer\"\n },\n \"timeout\": {\n \"maximum\": 4000,\n \"minimum\": 1,\n \"type\": \"integer\"\n },\n \"uri\": {\n \"maxLength\": 100,\n \"type\": \"string\"\n }\n }\n }\n }\n }\n }\n },\n \"required\": true\n}", + "use_request_body_schema_mode": false, + "validate_request_body_schema": false + } +} diff --git a/toolkits/arcade_engine_api/pyproject.toml b/toolkits/arcade_engine_api/pyproject.toml new file mode 100644 index 00000000..f7d6a459 --- /dev/null +++ b/toolkits/arcade_engine_api/pyproject.toml @@ -0,0 +1,60 @@ +[build-system] +requires = [ "hatchling",] +build-backend = "hatchling.build" + +[project] +name = "arcade_engine_api" +version = "0.1.0" +description = "Tools that enable LLMs to interact directly with the engine API." +requires-python = ">=3.10" +dependencies = [ + "arcade-tdk>=3.0.0,<4.0.0", + "httpx[http2]>=0.27.2,<1.0.0", + "jsonschema>=4.0.0,<5.0.0", +] +[[project.authors]] +email = "support@arcade.dev" + +[project.optional-dependencies] +dev = [ + "arcade-mcp[all]>=1.2.0,<2.0.0", + "arcade-serve>=3.0.0,<4.0.0", + "pytest>=8.3.0,<8.4.0", + "pytest-cov>=4.0.0,<4.1.0", + "pytest-mock>=3.11.1,<3.12.0", + "pytest-asyncio>=0.24.0,<0.25.0", + "mypy>=1.5.1,<1.6.0", + "pre-commit>=3.4.0,<3.5.0", + "tox>=4.11.1,<4.12.0", + "ruff>=0.7.4,<0.8.0", +] + +# Tell Arcade.dev that this package is a toolkit +[project.entry-points.arcade_toolkits] +toolkit_name = "arcade_engine_api" + +# Use local path sources for arcade libs when working locally +[tool.uv.sources] +arcade-mcp = { path = "../../", editable = true } +arcade-serve = { path = "../../libs/arcade-serve/", editable = true } +arcade-tdk = { path = "../../libs/arcade-tdk/", editable = true } +[tool.mypy] +files = [ "arcade_engine_api/**/*.py",] +python_version = "3.10" +disallow_untyped_defs = "True" +disallow_any_unimported = "True" +no_implicit_optional = "True" +check_untyped_defs = "True" +warn_return_any = "True" +warn_unused_ignores = "True" +show_error_codes = "True" +ignore_missing_imports = "True" + +[tool.pytest.ini_options] +testpaths = [ "tests",] + +[tool.coverage.report] +skip_empty = true + +[tool.hatch.build.targets.wheel] +packages = [ "arcade_engine_api",] diff --git a/toolkits/arcade_engine_api/tests/__init__.py b/toolkits/arcade_engine_api/tests/__init__.py new file mode 100644 index 00000000..e69de29b