Emporix · Schema

AgentResponse

CompanyCommerceE-CommerceB2B CommerceHeadless CommerceComposable CommerceCommerce OrchestrationAgentic CommerceiPaaSSoftware-as-a-Service

Properties

Name Type Description
name object Localized name of the agent.
description object Description of the agent.
requiredScopes array Defines which caller types are allowed to execute the agent. Authorization is evaluated with OR semantics: access is granted if the caller matches at least one configured value. If this field is missi
userPrompt string LLM Prompt which describes how agent should work in a detailed way, which tools it could use to solve problems etc; it can contain examples and step by step guidance.
icon string The fa class of react icon.
tags array
outputFormat string Optional JSON Schema (provided as a JSON string) that constrains the structure of the agent's generated output. Use this when you need predictable, machine-readable output instead of free-form text.
enabled boolean Indicates whether the agent is enabled.
triggers array
agentCollaborations object
maxRecursionLimit integer Defines the maximum number of reasoning steps or internal calls an AI agent is allowed to perform during a single task. Helps prevent infinite loops or excessive resource usage.
enabledMemory boolean Defines whether session memory is stored between different agent calls. Memory is stored only for that agent and only within one `session-id`. The default is `false`. To keep conversational memory for
id string Identifier of the agent.
nativeTools object
llmConfig object
mcpServers object
handOff object
type object
templatePrompt string Prompt which is inherited from the template (if agent is created based on the template). The prompt provided by the user is then concatenated with this prompt.
metadata object
versions array Stored history of previous agent configurations. Present only when the request sets `allVersions=true`. Omitted otherwise.
View JSON Schema on GitHub

JSON Schema

emporix-agent-response-schema.json Raw ↑
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://raw.githubusercontent.com/api-evangelist/emporix/main/json-schema/emporix-agent-response-schema.json",
  "title": "AgentResponse",
  "x-generated": "2026-10-18",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/emporix-ai-service-openapi.yml#/components/schemas/AgentResponse",
  "allOf": [
    {
      "$ref": "#/$defs/BaseForAgentRequestAndResponse"
    },
    {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "Identifier of the agent."
        },
        "nativeTools": {
          "$ref": "#/$defs/NativeToolsResponse"
        },
        "llmConfig": {
          "oneOf": [
            {
              "$ref": "#/$defs/EmporixLlm"
            },
            {
              "$ref": "#/$defs/ApiKeyLlmResponse"
            },
            {
              "$ref": "#/$defs/SelfHostedLlmResponse"
            }
          ]
        },
        "mcpServers": {
          "$ref": "#/$defs/AgentMcpServersResponse"
        },
        "handOff": {
          "deprecated": true,
          "allOf": [
            {
              "$ref": "#/$defs/HandOff"
            }
          ]
        },
        "type": {
          "$ref": "#/$defs/AgentType"
        },
        "templatePrompt": {
          "type": "string",
          "description": "Prompt which is inherited from the template (if agent is created based on the template). The prompt provided by the user is then concatenated with this prompt."
        },
        "metadata": {
          "$ref": "#/$defs/AgentMetadataResponse"
        },
        "versions": {
          "type": "array",
          "description": "Stored history of previous agent configurations. Present only when the request sets `allVersions=true`. Omitted otherwise.",
          "items": {
            "$ref": "#/$defs/AgentVersion"
          }
        }
      }
    }
  ],
  "$defs": {
    "AgentCollaborations": {
      "type": "array",
      "description": "List of agent collaborations which allows an agent to hand off its task to other agents. Collaborations remain in the caller's session and do not enable memory by themselves.",
      "items": {
        "type": "object",
        "properties": {
          "agentId": {
            "type": "string",
            "description": "Identifier of the agent."
          },
          "description": {
            "type": "string",
            "description": "Description of the agent collaboration."
          }
        }
      }
    },
    "AgentMcpServerResponse": {
      "type": "object",
      "required": [
        "type"
      ],
      "properties": {
        "type": {
          "$ref": "#/$defs/McpServerType"
        },
        "mcpServer": {
          "allOf": [
            {
              "$ref": "#/$defs/McpServerResponse"
            },
            {
              "description": "Present for `custom` and `dynamic` attachments. If `expand=mcpServer` is **not** used, then only the `id` field is returned, otherwise all fields are returned."
            }
          ]
        },
        "domain": {
          "enum": [
            "customer",
            "extensibility",
            "order",
            "product",
            "frontend"
          ],
          "description": "Present for `predefined` attachments."
        },
        "tools": {
          "type": "array",
          "description": "Tool-name allow-list. Present for `predefined` attachments and for `dynamic` attachments when a subset is configured. Omitted on `dynamic` means all enabled tools on the MCP server.",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "AgentMcpServersResponse": {
      "type": "array",
      "description": "List of MCP servers which agents should have access to.",
      "items": {
        "$ref": "#/$defs/AgentMcpServerResponse"
      }
    },
    "AgentMetadataResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/MetadataResponse"
        },
        {
          "type": "object",
          "properties": {
            "modifiedBy": {
              "$ref": "#/$defs/ModifiedBy"
            },
            "changeNote": {
              "type": "string",
              "description": "Note stored for this live version."
            }
          }
        }
      ]
    },
    "AgentTrigger": {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "type": {
              "$ref": "#/$defs/TriggerType"
            }
          },
          "required": [
            "type"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "$ref": "#/$defs/CommerceEventsTriggerType"
            },
            "config": {
              "type": "object",
              "description": "Additional configuration for the trigger.",
              "properties": {
                "events": {
                  "type": "string",
                  "description": "List of events that trigger the agent."
                },
                "filter": {
                  "$ref": "#/$defs/CommerceEventTriggerFilter"
                },
                "eventScopes": {
                  "type": "array",
                  "description": "Optional IAM scopes used to obtain an Emporix token when the agent runs from a Commerce Event. When omitted or empty, the agent does not receive `emporix-token`. Each value must be a scope the caller is allowed to grant.",
                  "items": {
                    "type": "string"
                  },
                  "uniqueItems": true
                }
              },
              "required": [
                "events"
              ]
            }
          },
          "required": [
            "type",
            "config"
          ]
        }
      ]
    },
    "AgentType": {
      "type": "string",
      "description": "Type of the agent handling the request.",
      "enum": [
        "generic",
        "complaint",
        "anti_fraud"
      ]
    },
    "AgentVersion": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseForAgentRequestAndResponse"
        },
        {
          "type": "object",
          "properties": {
            "templatePrompt": {
              "type": "string",
              "description": "Prompt inherited from the template at the time of this version."
            },
            "nativeTools": {
              "$ref": "#/$defs/NativeToolsResponse"
            },
            "llmConfig": {
              "oneOf": [
                {
                  "$ref": "#/$defs/EmporixLlm"
                },
                {
                  "$ref": "#/$defs/ApiKeyLlmResponse"
                },
                {
                  "$ref": "#/$defs/SelfHostedLlmResponse"
                }
              ]
            },
            "mcpServers": {
              "$ref": "#/$defs/AgentMcpServersResponse"
            },
            "metadata": {
              "$ref": "#/$defs/AgentVersionMetadata"
            }
          },
          "required": [
            "metadata"
          ]
        }
      ]
    },
    "AgentVersionMetadata": {
      "type": "object",
      "required": [
        "version"
      ],
      "properties": {
        "version": {
          "type": "integer",
          "minimum": 1,
          "description": "Version number of this archived snapshot."
        },
        "modifiedAt": {
          "type": "string",
          "description": "Date and time when this version was stored. The value is an ISO-8601 instant. For example: `2022-04-30T13:18:02.379Z`"
        },
        "modifiedBy": {
          "$ref": "#/$defs/ModifiedBy"
        },
        "changeNote": {
          "type": "string",
          "description": "Note stored with this snapshot."
        }
      }
    },
    "ApiKeyLlm": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseLlm"
        },
        {
          "type": "object",
          "properties": {
            "provider": {
              "$ref": "#/$defs/ApiKeyLlmProvider"
            }
          },
          "required": [
            "provider"
          ]
        }
      ]
    },
    "ApiKeyLlmProvider": {
      "type": "string",
      "description": "Type of the LLM Provider. The supported providers allows you to provide your own API key. When using this providers, the `apiKey` property cannot be omitted.",
      "enum": [
        "openai",
        "google",
        "anthropic"
      ]
    },
    "ApiKeyLlmResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/ApiKeyLlm"
        },
        {
          "type": "object",
          "properties": {
            "token": {
              "$ref": "#/$defs/ExpandableTokenResponse"
            }
          }
        }
      ]
    },
    "BaseForAgentAndTemplate": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseForAgentAndTemplateAndHandOff"
        },
        {
          "type": "object",
          "properties": {
            "requiredScopes": {
              "type": "array",
              "description": "Defines which caller types are allowed to execute the agent.\nAuthorization is evaluated with OR semantics: access is granted if the caller\nmatches at least one configured value.\nIf this field is missing or empty, no scope-based restriction is applied.\n\nMatching rules:\n- anonymous: always grants access.\n- customer: requires scope `ai.agentexecution_manage_own`.\n- employee: requires scope `ai.agentexecution_manage`.\n- integration: requires scope `ai.agentexecution_manage`.\n\nIf no configured value matches, request is rejected with 403 Forbidden.\n",
              "items": {
                "type": "string",
                "enum": [
                  "anonymous",
                  "customer",
                  "employee",
                  "integration"
                ]
              }
            },
            "userPrompt": {
              "type": "string",
              "description": "LLM Prompt which describes how agent should work in a detailed way, which tools it could use to solve problems etc; it can contain examples and step by step guidance."
            },
            "icon": {
              "type": "string",
              "description": "The fa class of react icon."
            },
            "tags": {
              "type": "array",
              "items": {
                "type": "string",
                "description": "Markers that allow you to categorize the agent."
              }
            },
            "outputFormat": {
              "type": "string",
              "description": "Optional JSON Schema (provided as a JSON string) that constrains the structure of the agent's generated output. Use this when you need predictable, machine-readable output instead of free-form text.\n"
            },
            "enabled": {
              "type": "boolean",
              "description": "Indicates whether the agent is enabled.",
              "default": false
            }
          },
          "required": [
            "name"
          ]
        }
      ]
    },
    "BaseForAgentAndTemplateAndHandOff": {
      "type": "object",
      "properties": {
        "name": {
          "type": "object",
          "description": "Localized name of the agent.",
          "additionalProperties": {
            "type": "string"
          }
        },
        "description": {
          "type": "object",
          "description": "Description of the agent.",
          "additionalProperties": {
            "type": "string"
          }
        }
      }
    },
    "BaseForAgentRequestAndResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseForAgentAndTemplate"
        },
        {
          "type": "object",
          "properties": {
            "triggers": {
              "type": "array",
              "items": {
                "$ref": "#/$defs/AgentTrigger"
              }
            },
            "agentCollaborations": {
              "$ref": "#/$defs/AgentCollaborations"
            },
            "maxRecursionLimit": {
              "type": "integer",
              "description": "Defines the maximum number of reasoning steps or internal calls an AI agent is allowed to perform during a single task. Helps prevent infinite loops or excessive resource usage.",
              "default": 20,
              "minimum": 1,
              "maximum": 50
            },
            "enabledMemory": {
              "type": "boolean",
              "description": "Defines whether session memory is stored between different agent calls. Memory is stored only for that agent and only within one `session-id`. The default is `false`. To keep conversational memory for targets in `agentCollaborations`, it is recommended to set the flag to `true` on each target as well.",
              "default": false
            }
          },
          "required": [
            "userPrompt",
            "triggers"
          ]
        }
      ]
    },
    "BaseLlm": {
      "type": "object",
      "properties": {
        "model": {
          "type": "string",
          "description": "The exact name of the model."
        },
        "temperature": {
          "type": "number",
          "format": "float",
          "description": "Value between 0.1 and 1.0 (inclusive), in steps of 0.1. The lower value the more creative (but less stable) the model is.",
          "enum": [
            0.1,
            0.2,
            0.3,
            0.4,
            0.5,
            0.6,
            0.7,
            0.8,
            0.9,
            1.0
          ]
        },
        "maxTokens": {
          "type": "integer",
          "description": "The limit of tokens which agent can burn during one request session."
        }
      },
      "required": [
        "model"
      ]
    },
    "BaseManagedMcpServer": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "description": "Name of the MCP server."
        },
        "enabled": {
          "type": "boolean",
          "description": "An indicator whether the MCP server is enabled.",
          "default": false
        },
        "transport": {
          "$ref": "#/$defs/CustomMcpServerTransportType"
        }
      }
    },
    "BaseNativeTool": {
      "type": "object",
      "properties": {
        "type": {
          "$ref": "#/$defs/NativeToolType"
        },
        "name": {
          "type": "string",
          "description": "Name of the tool."
        },
        "enabled": {
          "type": "boolean",
          "description": "An indicator whether the tool is enabled.",
          "default": false
        }
      },
      "required": [
        "type",
        "name"
      ]
    },
    "CommerceEventTriggerCompoundFilter": {
      "type": "object",
      "description": "Filter that combines multiple conditions using logical operators.",
      "properties": {
        "op": {
          "$ref": "#/$defs/CommerceEventTriggerFilterLogicalOperator"
        },
        "conditions": {
          "type": "array",
          "description": "Nested filter conditions combined by the logical operator.",
          "items": {
            "$ref": "#/$defs/CommerceEventTriggerFilter"
          },
          "minItems": 1
        }
      },
      "required": [
        "op",
        "conditions"
      ]
    },
    "CommerceEventTriggerFilter": {
      "oneOf": [
        {
          "$ref": "#/$defs/CommerceEventTriggerLeafFilter"
        },
        {
          "$ref": "#/$defs/CommerceEventTriggerCompoundFilter"
        }
      ],
      "description": "Optional filter expression applied to commerce event payloads. When set, the agent is triggered only if the event payload matches the filter."
    },
    "CommerceEventTriggerFilterLogicalOperator": {
      "type": "string",
      "enum": [
        "$and",
        "$or"
      ],
      "description": "Logical operator used to combine multiple filter conditions."
    },
    "CommerceEventTriggerFilterScalarArrayValue": {
      "type": "array",
      "description": "Array value used by list-based operators in commerce event filters.",
      "items": {
        "$ref": "#/$defs/CommerceEventTriggerFilterScalarValue"
      },
      "minItems": 1
    },
    "CommerceEventTriggerFilterScalarValue": {
      "description": "Scalar value used in commerce event filter comparisons.",
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "number"
        },
        {
          "type": "boolean"
        }
      ]
    },
    "CommerceEventTriggerLeafFilter": {
      "description": "Filter condition applied to a single field in the commerce event payload.",
      "oneOf": [
        {
          "$ref": "#/$defs/CommerceEventTriggerLeafFilterNoRight"
        },
        {
          "$ref": "#/$defs/CommerceEventTriggerLeafFilterScalarRight"
        },
        {
          "$ref": "#/$defs/CommerceEventTriggerLeafFilterArrayRight"
        }
      ]
    },
    "CommerceEventTriggerLeafFilterArrayRight": {
      "type": "object",
      "description": "Filter condition for array membership operators.",
      "properties": {
        "left": {
          "type": "string",
          "description": "Dot-notation path to a field in the commerce event payload."
        },
        "op": {
          "type": "string",
          "enum": [
            "$in",
            "$notIn"
          ]
        },
        "right": {
          "$ref": "#/$defs/CommerceEventTriggerFilterScalarArrayValue"
        }
      },
      "required": [
        "left",
        "op",
        "right"
      ],
      "additionalProperties": false
    },
    "CommerceEventTriggerLeafFilterNoRight": {
      "type": "object",
      "description": "Filter condition for unary operators that do not accept `right`.",
      "properties": {
        "left": {
          "type": "string",
          "description": "Dot-notation path to a field in the commerce event payload."
        },
        "op": {
          "type": "string",
          "enum": [
            "$exists",
            "$notExists",
            "$isEmpty",
            "$notEmpty"
          ]
        }
      },
      "required": [
        "left",
        "op"
      ],
      "additionalProperties": false
    },
    "CommerceEventTriggerLeafFilterScalarRight": {
      "type": "object",
      "description": "Filter condition for scalar comparison operators.",
      "properties": {
        "left": {
          "type": "string",
          "description": "Dot-notation path to a field in the commerce event payload."
        },
        "op": {
          "type": "string",
          "enum": [
            "$eq",
            "$ne"
          ]
        },
        "right": {
          "$ref": "#/$defs/CommerceEventTriggerFilterScalarValue"
        }
      },
      "required": [
        "left",
        "op",
        "right"
      ],
      "additionalProperties": false
    },
    "CommerceEventsTriggerType": {
      "type": "string",
      "enum": [
        "commerce_events"
      ],
      "description": "Type of the trigger."
    },
    "CustomMcpServerResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseManagedMcpServer"
        },
        {
          "type": "object",
          "description": "An object representing customer's own implementation of the MCP server.",
          "properties": {
            "id": {
              "type": "string",
              "description": "Unique identifier of the MCP server."
            },
            "type": {
              "allOf": [
                {
                  "$ref": "#/$defs/ManagedMcpServerType"
                }
              ],
              "description": "Type of the managed MCP server resource."
            },
            "config": {
              "$ref": "#/$defs/McpServerConfigResponse"
            },
            "metadata": {
              "$ref": "#/$defs/MetadataResponse"
            }
          }
        }
      ]
    },
    "CustomMcpServerTransportType": {
      "type": "string",
      "enum": [
        "streamable_http",
        "sse"
      ],
      "description": "Type of the communication between the agent and the MCP server. The `streamable_http` protocol is recommended, since the `sse` protocol is deprecated as transport for custom MCP servers."
    },
    "DynamicMcpServerResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseManagedMcpServer"
        },
        {
          "type": "object",
          "properties": {
            "id": {
              "type": "string",
              "description": "Unique identifier of the MCP server."
            },
            "type": {
              "allOf": [
                {
                  "$ref": "#/$defs/ManagedMcpServerType"
                }
              ],
              "description": "For dynamic MCP servers it has to be set to `dynamic`."
            },
            "tools": {
              "type": "array",
              "description": "List of tools exposed by this MCP server.\n\n**The `tools` field is in preview mode** - some of the features may not be fully operational yet.",
              "items": {
                "$ref": "#/$defs/McpToolResponse"
              }
            },
            "metadata": {
              "$ref": "#/$defs/MetadataResponse"
            }
          }
        }
      ]
    },
    "EmporixLlm": {
      "allOf": [
        {
          "$ref": "#/$defs/BaseLlm"
        },
        {
          "type": "object",
          "properties": {
            "provider": {
              "type": "string",
              "description": "Type of the LLM Provider. The `emporix_openai` allows using the OpenAI token provided by Emporix. The token usage is limited. When using this provider `apiKey` property can be omitted.",
              "enum": [
                "emporix_openai"
              ]
            }
          },
          "required": [
            "provider"
          ]
        }
      ]
    },
    "EmporixOpenAiRagEmporixEmbeddingNativeToolConfig": {
      "type": "object",
      "properties": {
        "provider": {
          "allOf": [
            {
              "$ref": "#/$defs/RagLlmProvider"
            }
          ],
          "description": "For this type, it should be set to 'emporix_openai'."
        }
      },
      "required": [
        "provider"
      ]
    },
    "ExpandableOAuthResponse": {
      "oneOf": [
        {
          "$ref": "#/$defs/IdResponse"
        },
        {
          "$ref": "#/$defs/OAuthResponse"
        }
      ],
      "description": "The full response representing OAuth. If the `expand=oauth` is **not** used, then only `id` field is returned, otherwise all fields are returned."
    },
    "ExpandableTokenResponse": {
      "oneOf": [
        {
          "$ref": "#/$defs/IdResponse"
        },
        {
          "$ref": "#/$defs/ExpandedTokenResponse"
        }
      ],
      "description": "The full response representing token. If the `expand=token` is **not** used, then only `id` field is returned, otherwise all fields are returned."
    },
    "ExpandedTokenResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/IdResponse"
        },
        {
          "type": "object",
          "properties": {
            "name": {
              "type": "string",
              "description": "Name of the token."
            },
            "metadata": {
              "$ref": "#/$defs/MetadataResponse"
            }
          }
        }
      ]
    },
    "FileProcessingConfig": {
      "description": "Optional additional config for file processing (preview).\n\n**The `fileProcessingConfig` field is in preview mode** - some of the features may not be fully operational yet.",
      "type": "object",
      "properties": {
        "useResponsesApi": {
          "type": "boolean",
          "description": "When true, file processing uses the Responses API on the self-hosted LLM."
        },
        "extraModelKey": {
          "type": "string",
          "description": "Optional extra model identifier used for file processing."
        }
      }
    },
    "HandOff": {
      "type": "boolean",
      "deprecated": true,
      "description": "Deprecated. Indicates whether the agent is a hand-off agent. This field is no longer used. Clients should ignore it."
    },
    "IdResponse": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "Identifier of the resource."
        }
      }
    },
    "ManagedMcpServerType": {
      "type": "string",
      "enum": [
        "custom",
        "dynamic"
      ],
      "description": "Type of the managed MCP server resource. Possible values:\n* `custom`\n* `dynamic`\n\n  **The `dynamic` value is in preview mode** - some of the features may not be fully operational yet."
    },
    "McpServerConfig": {
      "type": "object",
      "properties": {
        "url": {
          "type": "string",
          "description": "URL of the MCP server."
        },
        "authorizationHeaderName": {
          "type": "string",
          "description": "Name of the header required for authorization, e.g. `Authorization`."
        }
      },
      "required": [
        "url"
      ]
    },
    "McpServerConfigResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/McpServerConfig"
        },
        {
          "type": "object",
          "properties": {
            "authorizationHeaderToken": {
              "$ref": "#/$defs/ExpandableTokenResponse"
            }
          }
        }
      ]
    },
    "McpServerResponse": {
      "oneOf": [
        {
          "$ref": "#/$defs/CustomMcpServerResponse"
        },
        {
          "$ref": "#/$defs/DynamicMcpServerResponse"
        }
      ]
    },
    "McpServerType": {
      "type": "string",
      "enum": [
        "custom",
        "predefined",
        "dynamic"
      ],
      "description": "Type of the MCP server attachment on an agent. The `custom` type references a tenant-managed MCP server with a URL. The `predefined` type references an Emporix domain MCP server. The `dynamic` type references a tenant-managed dynamic MCP server and may include an optional tool-name allow-list."
    },
    "McpToolConfigResponse": {
      "type": "object",
      "properties": {
        "requiredScopes": {
          "type": "array",
          "description": "OAuth scopes required to invoke the tool.",
          "items": {
            "type": "string"
          }
        },
        "inputSchema": {
          "type": "string",
          "description": "JSON Schema document describing the tool input, provided as a JSON string."
        },
        "invocation": {
          "$ref": "#/$defs/McpToolInvocationResponse"
        }
      }
    },
    "McpToolInvocationArgsLocation": {
      "type": "string",
      "enum": [
        "body",
        "query"
      ],
      "description": "Location of the tool arguments in the HTTP request. Defaults to `body` when omitted."
    },
    "McpToolInvocationMethod": {
      "type": "string",
      "enum": [
        "GET",
        "POST",
        "PUT",
        "PATCH",
        "DELETE"
      ],
      "description": "HTTP method used to invoke the Automation function."
    },
    "McpToolInvocationResponse": {
      "type": "object",
      "properties": {
        "functionId": {
          "type": "string",
          "description": "Identifier of the Automation function to invoke when the tool is called."
        },
        "method": {
          "$ref": "#/$defs/McpToolInvocationMethod"
        },
        "argsLocation": {
          "$ref": "#/$defs/McpToolInvocationArgsLocation"
        }
      }
    },
    "McpToolResponse": {
      "type": "object",
      "description": "Tool definition for a dynamic MCP server.\n\n**Dynamic MCP tools are in preview mode** - some of the features may not be fully operational yet.",
      "properties": {
        "name": {
          "type": "string",
          "description": "Unique name of the tool. Contains only letters, numbers, and underscores."
        },
        "description": {
          "type": "string",
          "description": "Human-readable description of the tool."
        },
        "prompt": {
          "type": "string",
          "description": "Prompt that defines when and why the agent should call this tool."
        },
        "enabled": {
          "type": "boolean",
          "description": "An indicator whether the tool is enabled."
        },
        "config": {
          "$ref": "#/$defs/McpToolConfigResponse"
        }
      }
    },
    "MetadataRequest": {
      "type": "object",
      "properties": {
        "version": {
          "minimum": 1,
          "type": "integer",
          "description": "Version of the object. The version is required during the update operation because of the optimistic locking mechanism."
        }
      },
      "required": [
        "version"
      ]
    },
    "MetadataResponse": {
      "allOf": [
        {
          "$ref": "#/$defs/MetadataRequest"
        },
        {
          "type": "object",
          "properties": {
            "createdAt": {
              "description": "Date and time when the object was created. The value is approved as an ISO-8601 representation of an Instant. For example: `2022-04-30T13:18:02.379Z`",
              "type": "string"
            },
            "modifiedAt": {
              "description": "Date and time when the object was last modified. The value is approved as an ISO-8601 representation of an Instant. For example: `2022-04-30T13:18:02.379Z`",
              "type": "string"
            }
          },
          "required": [
            "version",
            "createdAt",
            "modifiedAt"
          ]
        }
      ]
    },
    "ModifiedBy": {
      "type": "object",
      "description": "Who last changed the agent.",
      "required": [
        "type"
      ],
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "CUSTOMER",
            "EMPLOYEE",
            "EXTERNAL",
            "SYSTEM"
          ],
          "description": "Identity recorded for the change. `EXTERNAL` is assigned when the request authenticates with an API token. `SYSTEM` is used for automatic updates.\n"
        },
        "id": {
          "type": "string",
          "description": "Identifier of the customer or employee. Omitted for `EXTERNAL` and `SYSTEM`. `id` is the `Hybris-User-Id` header value when `CUSTOMER` or `EMPLOYEE`."
        },
        "firstName": {
          "type": "string",
          "description": "First name of the customer or employee."
        },
        "lastName": {
          "type": "string",
          "description": "Last name of the customer or employee."
        }
      }
    },
    "NativeToolType": {
      "type": "string",
      "enum": [
        "slack",
        "rag_custom",
        "rag_emporix",
        "teams"
      ],
      "description": "Type of the native tool. Possible values:\n* `slack`\n* `rag_custom`\n* `rag_emporix`\n* `teams`"
    },
    "NativeToolsResponse": {
      "type": "array",
      "description": "List of native tools which agents should have access to.",
      "items": {
        "oneOf": [
          {
            "$ref": "#/$defs/SlackNativeToolResponse"
          },
          {
            "$ref": "#/$defs/RagCustomNativeToolResponse"
          },
          {
            "$ref": "#/$defs/RagEmporixNativeToolResponse"
          },
          {
            "$ref": "#/$defs/TeamsNativeToolResponse"
          }
        ]
      }
    },
    "OAuth": {
      "type": "object",
      "description": "OAuth 2.0 client-credentials settings for authenticating with a self-hosted LLM backend.",
      "properties": {
        "url": {
          "type": "string",
          "format": "uri",
          "description": "Token endpoint URL of the OAuth 2.0 authorization server used to request an access token."
        },
        "clientId": {
          "type": "string",
          "description": "OAuth 2.0 client identifier registered with the authorization server."
        },
        "grantType": {
          "type": "string",
          "description": "OAuth 2.0 grant type used to obtain an access token. Currently only `client_credentials` is supported.",
          "enum": [
            "client_credentials"
          ]
        },
        "scope": {
          "type": "string",
          "description": "Optional space-separated list of scopes to request for the access token."
        },
        "enabled": {
          "type": "boolean",
        

# --- truncated at 32 KB (48 KB total) ---
# Full source: https://artifacts.apis.io/emporix/json-schema/emporix-agent-response-schema.json

Work with this as data

Every JSON Schema here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for schemas

4 MCP tools reach this
  • find_json_schemasBrowse and filter every JSON Schema in the catalog.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This JSON Schema
curl "https://apis.io/api/v1/json-schemas/emporix-agent-response"
All schemas
curl "https://apis.io/api/v1/json-schemas?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.