Emporix · Schema

AgentResponse

CompanyCommerceE-CommerceB2B CommerceHeadless CommerceComposable CommerceCommerce OrchestrationAgentic CommerceiPaaSSoftware-as-a-Service
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"

Discovery needs no key. Ratings and market analysis are Pro.

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.