Integrations

class IntegrationsClient(*, sdk_config: SDKConfiguration, generated_client: ApiClient)

Bases: object

Client for managing Arize integrations (LLM and agent).

This class is primarily intended for internal use within the SDK. Users are highly encouraged to access resource-specific functionality via arize.ArizeClient.

The integrations client is a thin wrapper around the generated REST API client, using the shared generated API client owned by arize.config.SDKConfiguration.

Integrations are polymorphic: LLM integrations configure a model provider (OPEN_AI, ANTHROPIC, GEMINI, AWS_BEDROCK, CUSTOM, VERTEX_AI, NVIDIA_NIM, LITELLM, or FIREWORKS), while AGENT integrations connect a customer-hosted agent exposed at an HTTP endpoint. The integration IntegrationType selects the config shape.

Parameters:

• sdk_config (SDKConfiguration) – Resolved SDK configuration.

• generated_client (ApiClient) – Shared generated API client instance.

list(*, integration_type: IntegrationType | None = None, name: str | None = None, space: str | None = None, limit: int = DEFAULT_LIST_LIMIT, cursor: str | None = None) → ListIntegrationsResponse

List integrations the user has access to.

When integration_type is omitted, integrations of every type are returned in one merged list; each item carries its type. Integrations are returned in descending creation order (most recently created first).

Parameters:

• integration_type (IntegrationType | None) – Optional filter to a single integration type (LLM or AGENT).

• name (str | None) – Optional case-insensitive substring filter on the integration name.

• space (str | None) – Optional space filter. If the value is a base64-encoded resource ID it is treated as a space ID; otherwise it is used as a case-insensitive substring filter on the space name.

• limit (int) – Maximum number of integrations to return. The server may enforce an upper bound (max 100).

• cursor (str | None) – Opaque pagination cursor from a previous response.

Returns:

A response object with the integrations and pagination information.

Raises:

ApiException – If the REST API returns an error response (e.g. 400/401/403/429).

Return type:

ListIntegrationsResponse

get(*, integration: str, integration_type: IntegrationType | None = None, space: str | None = None) → AgentIntegration | LlmIntegration

Get an integration by ID or name.

Parameters:

• integration (str) – Integration ID or name. If a name is provided, integration_type is used to resolve it (and space if given).

• integration_type (IntegrationType | None) – The integration type used to resolve integration by name. Names are only unique per (account, type), so this is required when integration is a name; it is ignored when integration is an ID.

• space (str | None) – Optional space ID or name. This is only a visibility filter, not required to resolve a name.

Returns:

The concrete integration object (AgentIntegration or LlmIntegration).

Raises:

• NotFoundError – If integration is a name and integration_type is not provided, or the name cannot be resolved.

• ApiException – If the REST API returns an error response (e.g. 401/403/404/429).

Return type:

AgentIntegration | LlmIntegration

create_llm(*, name: str, config: CreateLlmConfigInput, scopings: builtins.list[IntegrationScopingRequest] | None = None) → LlmIntegration

Create an LLM integration.

LLM integrations configure access to a model provider for use within the Arize platform. All 9 providers are supported; construct the matching generated config for the config argument:

• OPEN_AI — CreateOpenAiConfig

• ANTHROPIC — CreateAnthropicConfig

• GEMINI — CreateGeminiConfig

• AWS_BEDROCK — CreateAwsBedrockConfig (nests a CreateAwsBedrockAuth: DEFAULT, BEARER_TOKEN, or PROXY_WITH_HEADERS)

• CUSTOM — CreateCustomConfig

• VERTEX_AI — CreateVertexAiConfig

• NVIDIA_NIM — CreateNvidiaNimConfig

• LITELLM — CreateLiteLlmConfig

• FIREWORKS — CreateFireworksConfig

Integration names must be unique within the account for the LLM type.

Parameters:

• name (str) – Integration name (must be unique within the account per type).

• config (CreateLlmConfigInput) – The provider-specific config. Accepts any of the 9 generated per-provider Create*Config objects, or a pre-wrapped CreateLlmConfig union.

• scopings (builtins.list[IntegrationScopingRequest] | None) – Visibility scoping rules. Defaults to account-wide if omitted.

Returns:

The created LLM integration.

Raises:

ApiException – If the REST API returns an error response (e.g. 400/401/403/409/422/429).

Return type:

LlmIntegration

create_agent(*, name: str, endpoint: str, input_schema: dict[str, Any], description: str | None = None, headers: dict[str, str] | None = None, request_presets: builtins.list[CreateAgentRequestPresetInput] | None = None, scopings: builtins.list[IntegrationScopingRequest] | None = None) → AgentIntegration

Create an agent integration.

Agent integrations connect a customer-hosted agent exposed at an HTTPS endpoint. Integration names must be unique within the account for the AGENT type.

Parameters:

• name (str) – Integration name (must be unique within the account per type).

• endpoint (str) – HTTPS endpoint URL Arize calls for replay. Validated server-side for SSRF (must resolve to a public address).

• input_schema (dict[str, Any]) – JSON Schema (Draft-07) the endpoint’s request body conforms to.

• description (str | None) – Optional human-readable description of the integration.

• headers (dict[str, str] | None) – Optional custom headers to include in requests. Encrypted at rest and never returned in responses.

• request_presets (builtins.list[CreateAgentRequestPresetInput] | None) – Optional initial named request presets.

• scopings (builtins.list[IntegrationScopingRequest] | None) – Visibility scoping rules. Defaults to account-wide if omitted.

Returns:

The created agent integration.

Raises:

ApiException – If the REST API returns an error response (e.g. 400/401/403/409/422/429).

Return type:

AgentIntegration

update_llm(*, integration: str, space: str | None = None, name: str | UNSET = _UNSET, api_key: str | None | UNSET = _UNSET, function_calling_enabled: bool | UNSET = _UNSET, auth: CreateAwsBedrockAuth | UNSET = _UNSET, base_url: str | None | UNSET = _UNSET, headers: dict[str, str] | None | UNSET = _UNSET, is_default_models_enabled: bool | UNSET = _UNSET, model_names: builtins.list[str] | UNSET = _UNSET, project_id: str | UNSET = _UNSET, location: str | UNSET = _UNSET, project_access_label: str | UNSET = _UNSET, scopings: builtins.list[IntegrationScopingRequest] | UNSET = _UNSET) → LlmIntegration

Update an LLM integration by ID or name.

At least one updatable field must be provided; otherwise a ValueError is raised (the server rejects type-only PATCHes). Only the fields you pass are sent to the server; omitted fields are left unchanged. The provider is immutable. The config fields map to the flat UpdateLlmConfig and are provider-conditional; the server rejects fields that do not apply to the stored provider with a 422, so pass only the fields valid for that provider:

• api_key, function_calling_enabled — all providers except AWS_BEDROCK and VERTEX_AI.

• auth — AWS_BEDROCK only; replaces the stored auth wholesale.

• base_url, headers — CUSTOM, NVIDIA_NIM, and LITELLM only.

• is_default_models_enabled — AWS_BEDROCK, CUSTOM, NVIDIA_NIM, and FIREWORKS only.

• model_names — AWS_BEDROCK, CUSTOM, NVIDIA_NIM, LITELLM, and FIREWORKS only.

• project_id, location, project_access_label — VERTEX_AI only.

Nullable fields (api_key, base_url, headers) accept an explicit None to clear them (omit to keep unchanged).

Parameters:

• integration (str) – Integration ID or name. If a name is provided, it is resolved using the LLM type (and space if given).

• space (str | None) – Optional space ID or name. Integration names are unique per (account, type), so this is only a visibility filter, not required to resolve a name.

• name (str | UNSET) – New integration name. Must be unique within the account per type.

• api_key (str | None | UNSET) – New API key. Pass None to clear the existing key.

• function_calling_enabled (bool | UNSET) – Updated function calling flag.

• auth (CreateAwsBedrockAuth | UNSET) – Replacement AWS Bedrock auth (CreateAwsBedrockAuth).

• base_url (str | None | UNSET) – New endpoint URL. Pass None to clear (NVIDIA_NIM; CUSTOM and LITELLM reject None with a 422).

• headers (dict[str, str] | None | UNSET) – Replacement custom request headers as a name-to-value map. Pass None to clear all headers.

• is_default_models_enabled (bool | UNSET) – Toggle Arize’s default model catalog.

• model_names (builtins.list[str] | UNSET) – Replacement custom model list.

• project_id (str | UNSET) – New Vertex AI GCP project ID.

• location (str | UNSET) – New Vertex AI GCP region.

• project_access_label (str | UNSET) – New Vertex AI project-access label.

• scopings (builtins.list[IntegrationScopingRequest] | UNSET) – Replacement visibility scoping rules (replaces all existing).

Returns:

The updated LLM integration.

Raises:

• ValueError – If no updatable field is provided.

• ApiException – If the REST API returns an error response (e.g. 400/401/403/404/409/422/429).

Return type:

LlmIntegration

update_agent(*, integration: str, space: str | None = None, name: str | UNSET = _UNSET, description: str | None | UNSET = _UNSET, endpoint: str | UNSET = _UNSET, input_schema: dict[str, Any] | UNSET = _UNSET, headers: dict[str, str] | None | UNSET = _UNSET, request_presets: builtins.list[UpdateAgentRequestPresetInput] | UNSET = _UNSET, scopings: builtins.list[IntegrationScopingRequest] | UNSET = _UNSET) → AgentIntegration

Update an agent integration by ID or name.

At least one updatable field must be provided; otherwise a ValueError is raised (the server rejects type-only PATCHes). Only the fields you pass are sent to the server; omitted fields are left unchanged. Collection fields (headers, request_presets, scopings) replace the existing values when provided. To clear nullable fields (description, headers), pass None.

Parameters:

• integration (str) – Integration ID or name. If a name is provided, it is resolved using the AGENT type (and space if given).

• space (str | None) – Optional space ID or name. Integration names are unique per (account, type), so this is only a visibility filter, not required to resolve a name.

• name (str | UNSET) – New integration name. Must be unique within the account per type.

• description (str | None | UNSET) – New description. Pass None to clear.

• endpoint (str | UNSET) – New HTTPS endpoint URL.

• input_schema (dict[str, Any] | UNSET) – New JSON Schema for the request payload shape.

• headers (dict[str, str] | None | UNSET) – Replacement custom headers. Pass None (or {}) to clear all headers.

• request_presets (builtins.list[UpdateAgentRequestPresetInput] | UNSET) – Replacement request presets, matched by name.

• scopings (builtins.list[IntegrationScopingRequest] | UNSET) – Replacement visibility scoping rules (replaces all existing).

Returns:

The updated agent integration.

Raises:

• ValueError – If no updatable field is provided.

• ApiException – If the REST API returns an error response (e.g. 400/401/403/404/409/422/429).

Return type:

AgentIntegration

delete(*, integration: str, integration_type: IntegrationType | None = None, space: str | None = None) → None

Delete an integration by ID or name.

This operation is irreversible.

Parameters:

• integration (str) – Integration ID or name. If a name is provided, integration_type is used to resolve it (and space if given).

• integration_type (IntegrationType | None) – The integration type used to resolve integration by name. Names are only unique per (account, type), so this is required when integration is a name; it is ignored when integration is an ID.

• space (str | None) – Optional space ID or name. This is only a visibility filter, not required to resolve a name.

Returns:

This method returns None on success (common empty 204 response).

Raises:

• NotFoundError – If integration is a name and integration_type is not provided, or the name cannot be resolved.

• ApiException – If the REST API returns an error response (e.g. 401/403/404/429).

Return type:

None

Response Types

Public types for the integrations subdomain.

class AgentConfig(*, endpoint: Annotated[str, Strict(strict=True), MaxLen(max_length=2048)], has_headers: Annotated[bool, Strict(strict=True)], input_schema: Dict[str, Any], request_presets: List[AgentRequestPreset], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Configuration for type: AGENT integrations: a customer-hosted HTTPS endpoint plus a JSON Schema describing the request payload.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• endpoint (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=2048)])])

• has_headers (Annotated[bool, Strict(strict=True)])

• input_schema (Dict[str, Any])

• request_presets (List[AgentRequestPreset])

• additional_properties (Dict[str, Any])

endpoint: Annotated[str, Field(strict=True, max_length=2048)]

has_headers: StrictBool

input_schema: Dict[str, Any]

request_presets: List[AgentRequestPreset]

additional_properties: Dict[str, Any]

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AgentConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• OpenAPI readOnly fields are excluded.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AgentConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AgentIntegration(*, id: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], description: Annotated[str, Strict(strict=True)] | None = None, scopings: List[IntegrationScoping], created_at: datetime, updated_at: datetime, created_by_user_id: Annotated[str, Strict(strict=True)] | None, config: AgentConfig)

Bases: BaseModel

An agent integration (type=AGENT): a customer-hosted HTTPS endpoint plus a JSON Schema describing the request payload.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• id (Annotated[str, Strict(strict=True)])

• type (Annotated[str, Strict(strict=True)])

• name (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• scopings (List[IntegrationScoping])

• created_at (datetime)

• updated_at (datetime)

• created_by_user_id (Annotated[str, Strict(strict=True)] | None)

• config (AgentConfig)

id: StrictStr

type: StrictStr

name: StrictStr

description: StrictStr | None

scopings: List[IntegrationScoping]

created_at: datetime

updated_at: datetime

created_by_user_id: StrictStr | None

config: AgentConfig

classmethod type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AgentIntegration from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AgentIntegration from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AgentRequestPreset(*, id: Annotated[str, Strict(strict=True)] | None = None, name: Annotated[str, Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)], description: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=1024)])] | None = None, config: Dict[str, Any], created_at: datetime | None = None, updated_at: datetime | None = None, additional_properties: Dict[str, Any] = {})

Bases: BaseModel

A named, reusable request payload bound to an agent integration. Embedded in agent.config.request_presets[]. There is no standalone preset endpoint; presets are managed exclusively via the nested collection on the parent integration. Validation rules: - name is unique within the integration (case-sensitive). Length 1-255. - description length 0-1024 (nullable). - config must conform to the integration’s input_schema with `required` dropped (present fields validated; missing fields ignored).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• id (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])])

• description (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=1024)])] | None)

• config (Dict[str, Any])

• created_at (datetime | None)

• updated_at (datetime | None)

• additional_properties (Dict[str, Any])

id: StrictStr | None

name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]

description: Annotated[str, Field(strict=True, max_length=1024)] | None

config: Dict[str, Any]

created_at: datetime | None

updated_at: datetime | None

additional_properties: Dict[str, Any]

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AgentRequestPreset from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• OpenAPI readOnly fields are excluded.

• OpenAPI readOnly fields are excluded.

• OpenAPI readOnly fields are excluded.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AgentRequestPreset from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AnthropicConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)] | None, additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for an Anthropic LLM integration.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)] | None)

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

base_url: StrictStr | None

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AnthropicConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AnthropicConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AwsBedrockAuth(*args, oneof_schema_1_validator: AwsBedrockDefaultAuth | None = None, oneof_schema_2_validator: AwsBedrockBearerTokenAuth | None = None, oneof_schema_3_validator: AwsBedrockProxyWithHeadersAuth | None = None, actual_instance: AwsBedrockBearerTokenAuth | AwsBedrockDefaultAuth | AwsBedrockProxyWithHeadersAuth | None = None, one_of_schemas: Set[str] = {'AwsBedrockBearerTokenAuth', 'AwsBedrockDefaultAuth', 'AwsBedrockProxyWithHeadersAuth'}, discriminator_value_class_map: Dict[str, str] = {})

Bases: BaseModel

AWS Bedrock auth settings, discriminated by auth_type.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• oneof_schema_1_validator (AwsBedrockDefaultAuth | None)

• oneof_schema_2_validator (AwsBedrockBearerTokenAuth | None)

• oneof_schema_3_validator (AwsBedrockProxyWithHeadersAuth | None)

• actual_instance (AwsBedrockBearerTokenAuth | AwsBedrockDefaultAuth | AwsBedrockProxyWithHeadersAuth | None)

• one_of_schemas (Set[str])

• discriminator_value_class_map (Dict[str, str])

oneof_schema_1_validator: AwsBedrockDefaultAuth | None

oneof_schema_2_validator: AwsBedrockBearerTokenAuth | None

oneof_schema_3_validator: AwsBedrockProxyWithHeadersAuth | None

actual_instance: AwsBedrockBearerTokenAuth | AwsBedrockDefaultAuth | AwsBedrockProxyWithHeadersAuth | None

one_of_schemas: Set[str]

model_config: ClassVar[ConfigDict] = {'protected_namespaces': (), 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

discriminator_value_class_map: Dict[str, str]

classmethod actual_instance_must_validate_oneof(v)

classmethod from_dict(obj: str | Dict[str, Any]) → Self

Parameters:

obj (str | Dict[str, Any])

Return type:

Self

classmethod from_json(json_str: str) → Self

Returns the object represented by the json string

Parameters:

json_str (str)

Return type:

Self

to_json() → str

Returns the JSON representation of the actual instance

Return type:

str

to_dict() → Dict[str, Any] | AwsBedrockBearerTokenAuth | AwsBedrockDefaultAuth | AwsBedrockProxyWithHeadersAuth | None

Returns the dict representation of the actual instance

Return type:

Dict[str, Any] | AwsBedrockBearerTokenAuth | AwsBedrockDefaultAuth | AwsBedrockProxyWithHeadersAuth | None

to_str() → str

Returns the string representation of the actual instance

Return type:

str

class AwsBedrockBearerTokenAuth(*, auth_type: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)] | None)

Bases: BaseModel

Bearer-token auth for AWS Bedrock. The token surfaces as has_api_key on read; the token itself is never returned.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• auth_type (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)] | None)

auth_type: StrictStr

has_api_key: StrictBool

base_url: StrictStr | None

classmethod auth_type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AwsBedrockBearerTokenAuth from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AwsBedrockBearerTokenAuth from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AwsBedrockConfig(*, provider: Annotated[str, Strict(strict=True)], is_default_models_enabled: Annotated[bool, Strict(strict=True)], model_names: List[Annotated[str, Strict(strict=True)]], auth: AwsBedrockAuth, additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for an AWS Bedrock LLM integration. The model catalog is caller-controlled via is_default_models_enabled and model_names. Function/tool-calling settings do not apply to Bedrock and are omitted.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• provider (Annotated[str, Strict(strict=True)])

• is_default_models_enabled (Annotated[bool, Strict(strict=True)])

• model_names (List[Annotated[str, Strict(strict=True)]])

• auth (AwsBedrockAuth)

• additional_properties (Dict[str, Any])

provider: StrictStr

is_default_models_enabled: StrictBool

model_names: List[StrictStr]

auth: AwsBedrockAuth

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AwsBedrockConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AwsBedrockConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AwsBedrockDefaultAuth(*, auth_type: Annotated[str, Strict(strict=True)], role_arn: Annotated[str, Strict(strict=True)], external_id: Annotated[str, Strict(strict=True)] | None, base_url: Annotated[str, Strict(strict=True)] | None)

Bases: BaseModel

Role-assumption auth for AWS Bedrock: Arize assumes the provided IAM role to call Bedrock. The role ARN and external ID are not secrets and are returned on read.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• auth_type (Annotated[str, Strict(strict=True)])

• role_arn (Annotated[str, Strict(strict=True)])

• external_id (Annotated[str, Strict(strict=True)] | None)

• base_url (Annotated[str, Strict(strict=True)] | None)

auth_type: StrictStr

role_arn: StrictStr

external_id: StrictStr | None

base_url: StrictStr | None

classmethod auth_type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AwsBedrockDefaultAuth from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AwsBedrockDefaultAuth from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class AwsBedrockProxyWithHeadersAuth(*, auth_type: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)], header_names: List[Annotated[str, Strict(strict=True)]])

Bases: BaseModel

Proxy auth for AWS Bedrock: requests are forwarded to a proxy URL with custom headers. Header values are write-only; configured names are returned as header_names.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• auth_type (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)])

• header_names (List[Annotated[str, Strict(strict=True)]])

auth_type: StrictStr

base_url: StrictStr

header_names: List[StrictStr]

classmethod auth_type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of AwsBedrockProxyWithHeadersAuth from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AwsBedrockProxyWithHeadersAuth from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateAgentRequestPresetInput(*, name: Annotated[str, Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)], description: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=1024)])] | None = None, config: Dict[str, Any])

Bases: BaseModel

Write shape for an agent request preset on create. Server-generated fields (id, created_at, updated_at) are not accepted on input.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• name (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])])

• description (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=1024)])] | None)

• config (Dict[str, Any])

name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]

description: Annotated[str, Field(strict=True, max_length=1024)] | None

config: Dict[str, Any]

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateAgentRequestPresetInput from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateAgentRequestPresetInput from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateAnthropicConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Create config for an Anthropic LLM integration. api_key is required and is write-only (never returned in responses). base_url is optional; omit it to use the public Anthropic API.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)] | None)

is_function_calling_enabled: StrictBool | None

provider: StrictStr

api_key: StrictStr

base_url: StrictStr | None

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateAnthropicConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateAnthropicConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateAwsBedrockAuth(*args, oneof_schema_1_validator: CreateAwsBedrockDefaultAuth | None = None, oneof_schema_2_validator: CreateAwsBedrockBearerTokenAuth | None = None, oneof_schema_3_validator: CreateAwsBedrockProxyWithHeadersAuth | None = None, actual_instance: CreateAwsBedrockBearerTokenAuth | CreateAwsBedrockDefaultAuth | CreateAwsBedrockProxyWithHeadersAuth | None = None, one_of_schemas: Set[str] = {'CreateAwsBedrockBearerTokenAuth', 'CreateAwsBedrockDefaultAuth', 'CreateAwsBedrockProxyWithHeadersAuth'}, discriminator_value_class_map: Dict[str, str] = {})

Bases: BaseModel

AWS Bedrock auth settings for create and update, discriminated by auth_type. On PATCH this object replaces the stored auth settings wholesale (auth_type may change); omitted fields of the previous auth mode are cleared.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• oneof_schema_1_validator (CreateAwsBedrockDefaultAuth | None)

• oneof_schema_2_validator (CreateAwsBedrockBearerTokenAuth | None)

• oneof_schema_3_validator (CreateAwsBedrockProxyWithHeadersAuth | None)

• actual_instance (CreateAwsBedrockBearerTokenAuth | CreateAwsBedrockDefaultAuth | CreateAwsBedrockProxyWithHeadersAuth | None)

• one_of_schemas (Set[str])

• discriminator_value_class_map (Dict[str, str])

oneof_schema_1_validator: CreateAwsBedrockDefaultAuth | None

oneof_schema_2_validator: CreateAwsBedrockBearerTokenAuth | None

oneof_schema_3_validator: CreateAwsBedrockProxyWithHeadersAuth | None

actual_instance: CreateAwsBedrockBearerTokenAuth | CreateAwsBedrockDefaultAuth | CreateAwsBedrockProxyWithHeadersAuth | None

one_of_schemas: Set[str]

model_config: ClassVar[ConfigDict] = {'protected_namespaces': (), 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

discriminator_value_class_map: Dict[str, str]

classmethod actual_instance_must_validate_oneof(v)

classmethod from_dict(obj: str | Dict[str, Any]) → Self

Parameters:

obj (str | Dict[str, Any])

Return type:

Self

classmethod from_json(json_str: str) → Self

Returns the object represented by the json string

Parameters:

json_str (str)

Return type:

Self

to_json() → str

Returns the JSON representation of the actual instance

Return type:

str

to_dict() → Dict[str, Any] | CreateAwsBedrockBearerTokenAuth | CreateAwsBedrockDefaultAuth | CreateAwsBedrockProxyWithHeadersAuth | None

Returns the dict representation of the actual instance

Return type:

Dict[str, Any] | CreateAwsBedrockBearerTokenAuth | CreateAwsBedrockDefaultAuth | CreateAwsBedrockProxyWithHeadersAuth | None

to_str() → str

Returns the string representation of the actual instance

Return type:

str

class CreateAwsBedrockBearerTokenAuth(*, auth_type: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Create bearer-token auth. api_key is required and write-only (never returned; surfaces as has_api_key on read).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• auth_type (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)] | None)

auth_type: StrictStr

api_key: StrictStr

base_url: StrictStr | None

classmethod auth_type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateAwsBedrockBearerTokenAuth from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateAwsBedrockBearerTokenAuth from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateAwsBedrockConfig(*, provider: Annotated[str, Strict(strict=True)], auth: CreateAwsBedrockAuth, is_default_models_enabled: Annotated[bool, Strict(strict=True)] | None = None, model_names: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Create config for an AWS Bedrock LLM integration. auth selects one of three auth modes via auth_type. The integration must have at least one model available: enable is_default_models_enabled or provide at least one entry in model_names, otherwise the request is rejected with 422.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• provider (Annotated[str, Strict(strict=True)])

• auth (CreateAwsBedrockAuth)

• is_default_models_enabled (Annotated[bool, Strict(strict=True)] | None)

• model_names (List[Annotated[str, Strict(strict=True)]] | None)

provider: StrictStr

auth: CreateAwsBedrockAuth

is_default_models_enabled: StrictBool | None

model_names: List[StrictStr] | None

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateAwsBedrockConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateAwsBedrockConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateAwsBedrockDefaultAuth(*, auth_type: Annotated[str, Strict(strict=True)], role_arn: Annotated[str, Strict(strict=True)], external_id: Annotated[str, Strict(strict=True)] | None = None, base_url: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Create role-assumption auth. role_arn is required.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• auth_type (Annotated[str, Strict(strict=True)])

• role_arn (Annotated[str, Strict(strict=True)])

• external_id (Annotated[str, Strict(strict=True)] | None)

• base_url (Annotated[str, Strict(strict=True)] | None)

auth_type: StrictStr

role_arn: StrictStr

external_id: StrictStr | None

base_url: StrictStr | None

classmethod auth_type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateAwsBedrockDefaultAuth from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateAwsBedrockDefaultAuth from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateAwsBedrockProxyWithHeadersAuth(*, auth_type: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)], headers: Dict[str, Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Create proxy auth. base_url is required. headers is write-only; names are returned as header_names on read.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• auth_type (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)])

• headers (Dict[str, Annotated[str, Strict(strict=True)]] | None)

auth_type: StrictStr

base_url: StrictStr

headers: Dict[str, StrictStr] | None

classmethod auth_type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateAwsBedrockProxyWithHeadersAuth from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateAwsBedrockProxyWithHeadersAuth from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateCustomConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)] | None = None, headers: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, is_default_models_enabled: Annotated[bool, Strict(strict=True)] | None = None, model_names: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Create config for a custom OpenAI-compatible endpoint integration. base_url is required and must implement the OpenAI API shape (it is validated server-side and must resolve to a public address). api_key and headers are write-only (never returned; headers surface as header_names on read). The integration must have at least one model source: enable is_default_models_enabled or provide at least one entry in model_names, otherwise the request is rejected with 422.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)] | None)

• headers (Dict[str, Annotated[str, Strict(strict=True)]] | None)

• is_default_models_enabled (Annotated[bool, Strict(strict=True)] | None)

• model_names (List[Annotated[str, Strict(strict=True)]] | None)

is_function_calling_enabled: StrictBool | None

provider: StrictStr

base_url: StrictStr

api_key: StrictStr | None

headers: Dict[str, StrictStr] | None

is_default_models_enabled: StrictBool | None

model_names: List[StrictStr] | None

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateCustomConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateCustomConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateFireworksConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)], is_default_models_enabled: Annotated[bool, Strict(strict=True)] | None = None, model_names: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Create config for a Fireworks AI integration. api_key is required and is write-only (never returned; it surfaces as has_api_key on read). Fireworks is a single hosted service, so there is no endpoint field and no custom request headers. Neither is_default_models_enabled nor model_names is required: Arize resolves the models the key can reach from the Fireworks account, so an integration created with neither still has a selectable model list.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)])

• is_default_models_enabled (Annotated[bool, Strict(strict=True)] | None)

• model_names (List[Annotated[str, Strict(strict=True)]] | None)

is_function_calling_enabled: StrictBool | None

provider: StrictStr

api_key: StrictStr

is_default_models_enabled: StrictBool | None

model_names: List[StrictStr] | None

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateFireworksConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateFireworksConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateGeminiConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Create config for a Google Gemini LLM integration. api_key is required and is write-only (never returned in responses).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)])

is_function_calling_enabled: StrictBool | None

provider: StrictStr

api_key: StrictStr

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateGeminiConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateGeminiConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateLiteLlmConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)], headers: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, model_names: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Create config for a LiteLLM integration. base_url is required and points at the LiteLLM endpoint (validated server-side); LiteLLM is self-hosted, so there is no default endpoint. api_key is required: the virtual key scopes the models Arize can resolve and call. api_key and headers are write-only (never returned; headers surface as header_names on read).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)])

• headers (Dict[str, Annotated[str, Strict(strict=True)]] | None)

• model_names (List[Annotated[str, Strict(strict=True)]] | None)

is_function_calling_enabled: StrictBool | None

provider: StrictStr

base_url: StrictStr

api_key: StrictStr

headers: Dict[str, StrictStr] | None

model_names: List[StrictStr] | None

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateLiteLlmConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateLiteLlmConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateLlmConfig(*args, oneof_schema_1_validator: CreateOpenAiConfig | None = None, oneof_schema_2_validator: CreateAnthropicConfig | None = None, oneof_schema_3_validator: CreateGeminiConfig | None = None, oneof_schema_4_validator: CreateAwsBedrockConfig | None = None, oneof_schema_5_validator: CreateCustomConfig | None = None, oneof_schema_6_validator: CreateVertexAiConfig | None = None, oneof_schema_7_validator: CreateNvidiaNimConfig | None = None, oneof_schema_8_validator: CreateLiteLlmConfig | None = None, oneof_schema_9_validator: CreateFireworksConfig | None = None, actual_instance: CreateAnthropicConfig | CreateAwsBedrockConfig | CreateCustomConfig | CreateFireworksConfig | CreateGeminiConfig | CreateLiteLlmConfig | CreateNvidiaNimConfig | CreateOpenAiConfig | CreateVertexAiConfig | None = None, one_of_schemas: Set[str] = {'CreateAnthropicConfig', 'CreateAwsBedrockConfig', 'CreateCustomConfig', 'CreateFireworksConfig', 'CreateGeminiConfig', 'CreateLiteLlmConfig', 'CreateNvidiaNimConfig', 'CreateOpenAiConfig', 'CreateVertexAiConfig'}, discriminator_value_class_map: Dict[str, str] = {})

Bases: BaseModel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• oneof_schema_1_validator (CreateOpenAiConfig | None)

• oneof_schema_2_validator (CreateAnthropicConfig | None)

• oneof_schema_3_validator (CreateGeminiConfig | None)

• oneof_schema_4_validator (CreateAwsBedrockConfig | None)

• oneof_schema_5_validator (CreateCustomConfig | None)

• oneof_schema_6_validator (CreateVertexAiConfig | None)

• oneof_schema_7_validator (CreateNvidiaNimConfig | None)

• oneof_schema_8_validator (CreateLiteLlmConfig | None)

• oneof_schema_9_validator (CreateFireworksConfig | None)

• actual_instance (CreateAnthropicConfig | CreateAwsBedrockConfig | CreateCustomConfig | CreateFireworksConfig | CreateGeminiConfig | CreateLiteLlmConfig | CreateNvidiaNimConfig | CreateOpenAiConfig | CreateVertexAiConfig | None)

• one_of_schemas (Set[str])

• discriminator_value_class_map (Dict[str, str])

oneof_schema_1_validator: CreateOpenAiConfig | None

oneof_schema_2_validator: CreateAnthropicConfig | None

oneof_schema_3_validator: CreateGeminiConfig | None

oneof_schema_4_validator: CreateAwsBedrockConfig | None

oneof_schema_5_validator: CreateCustomConfig | None

oneof_schema_6_validator: CreateVertexAiConfig | None

oneof_schema_7_validator: CreateNvidiaNimConfig | None

oneof_schema_8_validator: CreateLiteLlmConfig | None

oneof_schema_9_validator: CreateFireworksConfig | None

actual_instance: CreateAnthropicConfig | CreateAwsBedrockConfig | CreateCustomConfig | CreateFireworksConfig | CreateGeminiConfig | CreateLiteLlmConfig | CreateNvidiaNimConfig | CreateOpenAiConfig | CreateVertexAiConfig | None

one_of_schemas: Set[str]

model_config: ClassVar[ConfigDict] = {'protected_namespaces': (), 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

discriminator_value_class_map: Dict[str, str]

classmethod actual_instance_must_validate_oneof(v)

classmethod from_dict(obj: str | Dict[str, Any]) → Self

Parameters:

obj (str | Dict[str, Any])

Return type:

Self

classmethod from_json(json_str: str) → Self

Returns the object represented by the json string

Parameters:

json_str (str)

Return type:

Self

to_json() → str

Returns the JSON representation of the actual instance

Return type:

str

to_dict() → Dict[str, Any] | CreateAnthropicConfig | CreateAwsBedrockConfig | CreateCustomConfig | CreateFireworksConfig | CreateGeminiConfig | CreateLiteLlmConfig | CreateNvidiaNimConfig | CreateOpenAiConfig | CreateVertexAiConfig | None

Returns the dict representation of the actual instance

Return type:

Dict[str, Any] | CreateAnthropicConfig | CreateAwsBedrockConfig | CreateCustomConfig | CreateFireworksConfig | CreateGeminiConfig | CreateLiteLlmConfig | CreateNvidiaNimConfig | CreateOpenAiConfig | CreateVertexAiConfig | None

to_str() → str

Returns the string representation of the actual instance

Return type:

str

class CreateNvidiaNimConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)] | None = None, api_key: Annotated[str, Strict(strict=True)] | None = None, headers: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, is_default_models_enabled: Annotated[bool, Strict(strict=True)] | None = None, model_names: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Create config for an NVIDIA NIM integration. Every connection field is optional: omit base_url to use the provider default endpoint, or set it to a self-hosted NIM endpoint (validated server-side). api_key and headers are write-only (never returned; headers surface as header_names on read). The integration must have at least one model source: enable is_default_models_enabled or provide at least one entry in model_names, otherwise the request is rejected with 422.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)] | None)

• api_key (Annotated[str, Strict(strict=True)] | None)

• headers (Dict[str, Annotated[str, Strict(strict=True)]] | None)

• is_default_models_enabled (Annotated[bool, Strict(strict=True)] | None)

• model_names (List[Annotated[str, Strict(strict=True)]] | None)

is_function_calling_enabled: StrictBool | None

provider: StrictStr

base_url: StrictStr | None

api_key: StrictStr | None

headers: Dict[str, StrictStr] | None

is_default_models_enabled: StrictBool | None

model_names: List[StrictStr] | None

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateNvidiaNimConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateNvidiaNimConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateOpenAiConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, provider: Annotated[str, Strict(strict=True)], api_key: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Create config for an OpenAI LLM integration. api_key is required and is write-only (never returned in responses).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• provider (Annotated[str, Strict(strict=True)])

• api_key (Annotated[str, Strict(strict=True)])

is_function_calling_enabled: StrictBool | None

provider: StrictStr

api_key: StrictStr

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateOpenAiConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateOpenAiConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CreateVertexAiConfig(*, provider: Annotated[str, Strict(strict=True)], project_id: Annotated[str, Strict(strict=True)], location: Annotated[str, Strict(strict=True)], project_access_label: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Create config for a Google Vertex AI integration. No credentials are stored: Arize accesses Vertex through the configured GCP project. project_id, location, and project_access_label are all required.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• provider (Annotated[str, Strict(strict=True)])

• project_id (Annotated[str, Strict(strict=True)])

• location (Annotated[str, Strict(strict=True)])

• project_access_label (Annotated[str, Strict(strict=True)])

provider: StrictStr

project_id: StrictStr

location: StrictStr

project_access_label: StrictStr

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CreateVertexAiConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CreateVertexAiConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class CustomConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)], header_names: List[Annotated[str, Strict(strict=True)]], is_default_models_enabled: Annotated[bool, Strict(strict=True)], model_names: List[Annotated[str, Strict(strict=True)]], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for a custom OpenAI-compatible endpoint integration. base_url is the endpoint Arize sends requests to; it must implement the OpenAI API shape. Secrets are write-only: the API key surfaces as has_api_key and custom request headers surface as header_names (names only).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)])

• header_names (List[Annotated[str, Strict(strict=True)]])

• is_default_models_enabled (Annotated[bool, Strict(strict=True)])

• model_names (List[Annotated[str, Strict(strict=True)]])

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

base_url: StrictStr

header_names: List[StrictStr]

is_default_models_enabled: StrictBool

model_names: List[StrictStr]

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of CustomConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CustomConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class FireworksConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], is_default_models_enabled: Annotated[bool, Strict(strict=True)], model_names: List[Annotated[str, Strict(strict=True)]], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for a Fireworks AI integration. Fireworks is a single hosted service, so there is no endpoint field and no custom request headers. The API key is write-only and surfaces as has_api_key. model_names lists only the model names configured on this integration; models resolved live from the Fireworks account are served through the Arize UI and are not returned here.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• is_default_models_enabled (Annotated[bool, Strict(strict=True)])

• model_names (List[Annotated[str, Strict(strict=True)]])

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

is_default_models_enabled: StrictBool

model_names: List[StrictStr]

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of FireworksConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of FireworksConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class GeminiConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for a Google Gemini LLM integration.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of GeminiConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of GeminiConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class IntegrationScoping(*, organization_id: Annotated[str, Strict(strict=True)] | None = None, space_id: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Visibility scoping for the integration.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• organization_id (Annotated[str, Strict(strict=True)] | None)

• space_id (Annotated[str, Strict(strict=True)] | None)

organization_id: StrictStr | None

space_id: StrictStr | None

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of IntegrationScoping from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of IntegrationScoping from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class IntegrationType(value, names=_not_given, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

The integration category. Selects the shape of config. Additive — new types (alerting, webhook, …) are added non-breakingly. - LLM — a model-provider integration (e.g. OpenAI). - AGENT — connects your own agent, exposed at an HTTP endpoint. - EVALUATOR — connects a remote evaluator endpoint. Only returned when ?type=EVALUATOR is passed explicitly; excluded from the default (LLM + AGENT) list to keep the cursor contract stable. Requires the remote evaluators feature to be enabled.

LLM = 'LLM'

AGENT = 'AGENT'

EVALUATOR = 'EVALUATOR'

classmethod from_json(json_str: str) → Self

Create an instance of IntegrationType from a JSON string

Parameters:

json_str (str)

Return type:

Self

class ListIntegrationsResponse(*, integrations: list[AgentIntegration | LlmIntegration], pagination: PaginationMetadata)

Bases: BaseModel

SDK view of the generated list response with each Integration unwrapped.

The integrations field contains the concrete inner types (AgentIntegration or LlmIntegration) instead of the oneOf wrapper Integration.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• integrations (list[AgentIntegration | LlmIntegration])

• pagination (PaginationMetadata)

integrations: list[AgentIntegration | LlmIntegration]

pagination: PaginationMetadata

model_config: ClassVar[ConfigDict] = {'from_attributes': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class LiteLlmConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)], header_names: List[Annotated[str, Strict(strict=True)]], model_names: List[Annotated[str, Strict(strict=True)]], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for a LiteLLM integration. base_url is the LiteLLM endpoint Arize sends requests to and is always set — LiteLLM is self-hosted, so there is no default endpoint. Secrets are write-only: the virtual key surfaces as has_api_key and custom request headers surface as header_names (names only). model_names lists only the model names configured on this integration; models resolved live from the LiteLLM deployment are served through the Arize UI and are not returned here.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)])

• header_names (List[Annotated[str, Strict(strict=True)]])

• model_names (List[Annotated[str, Strict(strict=True)]])

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

base_url: StrictStr

header_names: List[StrictStr]

model_names: List[StrictStr]

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of LiteLlmConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of LiteLlmConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class LlmConfig(*args, oneof_schema_1_validator: OpenAiConfig | None = None, oneof_schema_2_validator: AnthropicConfig | None = None, oneof_schema_3_validator: GeminiConfig | None = None, oneof_schema_4_validator: AwsBedrockConfig | None = None, oneof_schema_5_validator: CustomConfig | None = None, oneof_schema_6_validator: VertexAiConfig | None = None, oneof_schema_7_validator: NvidiaNimConfig | None = None, oneof_schema_8_validator: LiteLlmConfig | None = None, oneof_schema_9_validator: FireworksConfig | None = None, actual_instance: AnthropicConfig | AwsBedrockConfig | CustomConfig | FireworksConfig | GeminiConfig | LiteLlmConfig | NvidiaNimConfig | OpenAiConfig | VertexAiConfig | None = None, one_of_schemas: Set[str] = {'AnthropicConfig', 'AwsBedrockConfig', 'CustomConfig', 'FireworksConfig', 'GeminiConfig', 'LiteLlmConfig', 'NvidiaNimConfig', 'OpenAiConfig', 'VertexAiConfig'}, discriminator_value_class_map: Dict[str, str] = {})

Bases: BaseModel

Per-provider LLM config, discriminated by provider.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• oneof_schema_1_validator (OpenAiConfig | None)

• oneof_schema_2_validator (AnthropicConfig | None)

• oneof_schema_3_validator (GeminiConfig | None)

• oneof_schema_4_validator (AwsBedrockConfig | None)

• oneof_schema_5_validator (CustomConfig | None)

• oneof_schema_6_validator (VertexAiConfig | None)

• oneof_schema_7_validator (NvidiaNimConfig | None)

• oneof_schema_8_validator (LiteLlmConfig | None)

• oneof_schema_9_validator (FireworksConfig | None)

• actual_instance (AnthropicConfig | AwsBedrockConfig | CustomConfig | FireworksConfig | GeminiConfig | LiteLlmConfig | NvidiaNimConfig | OpenAiConfig | VertexAiConfig | None)

• one_of_schemas (Set[str])

• discriminator_value_class_map (Dict[str, str])

oneof_schema_1_validator: OpenAiConfig | None

oneof_schema_2_validator: AnthropicConfig | None

oneof_schema_3_validator: GeminiConfig | None

oneof_schema_4_validator: AwsBedrockConfig | None

oneof_schema_5_validator: CustomConfig | None

oneof_schema_6_validator: VertexAiConfig | None

oneof_schema_7_validator: NvidiaNimConfig | None

oneof_schema_8_validator: LiteLlmConfig | None

oneof_schema_9_validator: FireworksConfig | None

actual_instance: AnthropicConfig | AwsBedrockConfig | CustomConfig | FireworksConfig | GeminiConfig | LiteLlmConfig | NvidiaNimConfig | OpenAiConfig | VertexAiConfig | None

one_of_schemas: Set[str]

model_config: ClassVar[ConfigDict] = {'protected_namespaces': (), 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

discriminator_value_class_map: Dict[str, str]

classmethod actual_instance_must_validate_oneof(v)

classmethod from_dict(obj: str | Dict[str, Any]) → Self

Parameters:

obj (str | Dict[str, Any])

Return type:

Self

classmethod from_json(json_str: str) → Self

Returns the object represented by the json string

Parameters:

json_str (str)

Return type:

Self

to_json() → str

Returns the JSON representation of the actual instance

Return type:

str

to_dict() → Dict[str, Any] | AnthropicConfig | AwsBedrockConfig | CustomConfig | FireworksConfig | GeminiConfig | LiteLlmConfig | NvidiaNimConfig | OpenAiConfig | VertexAiConfig | None

Returns the dict representation of the actual instance

Return type:

Dict[str, Any] | AnthropicConfig | AwsBedrockConfig | CustomConfig | FireworksConfig | GeminiConfig | LiteLlmConfig | NvidiaNimConfig | OpenAiConfig | VertexAiConfig | None

to_str() → str

Returns the string representation of the actual instance

Return type:

str

class LlmIntegration(*, id: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], scopings: List[IntegrationScoping], created_at: datetime, updated_at: datetime, created_by_user_id: Annotated[str, Strict(strict=True)], config: LlmConfig)

Bases: BaseModel

An LLM integration (type=LLM).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• id (Annotated[str, Strict(strict=True)])

• type (Annotated[str, Strict(strict=True)])

• name (Annotated[str, Strict(strict=True)])

• scopings (List[IntegrationScoping])

• created_at (datetime)

• updated_at (datetime)

• created_by_user_id (Annotated[str, Strict(strict=True)])

• config (LlmConfig)

id: StrictStr

type: StrictStr

name: StrictStr

scopings: List[IntegrationScoping]

created_at: datetime

updated_at: datetime

created_by_user_id: StrictStr

config: LlmConfig

classmethod type_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of LlmIntegration from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of LlmIntegration from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class LlmIntegrationProvider(value, names=_not_given, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

The LLM vendor for an LLM integration. Selects the per-provider config member. OPEN_AI, ANTHROPIC, GEMINI, AWS_BEDROCK, CUSTOM, VERTEX_AI, NVIDIA_NIM, LITELLM, and FIREWORKS are implemented; additional providers are added non-breakingly.

OPEN_AI = 'OPEN_AI'

ANTHROPIC = 'ANTHROPIC'

GEMINI = 'GEMINI'

AWS_BEDROCK = 'AWS_BEDROCK'

CUSTOM = 'CUSTOM'

VERTEX_AI = 'VERTEX_AI'

NVIDIA_NIM = 'NVIDIA_NIM'

LITELLM = 'LITELLM'

FIREWORKS = 'FIREWORKS'

classmethod from_json(json_str: str) → Self

Create an instance of LlmIntegrationProvider from a JSON string

Parameters:

json_str (str)

Return type:

Self

class NvidiaNimConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], base_url: Annotated[str, Strict(strict=True)] | None, header_names: List[Annotated[str, Strict(strict=True)]], is_default_models_enabled: Annotated[bool, Strict(strict=True)], model_names: List[Annotated[str, Strict(strict=True)]], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for an NVIDIA NIM integration. Every connection field is optional: base_url targets a self-hosted NIM endpoint (null when using the provider default). Secrets are write-only: the API key surfaces as has_api_key and custom request headers surface as header_names (names only).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• base_url (Annotated[str, Strict(strict=True)] | None)

• header_names (List[Annotated[str, Strict(strict=True)]])

• is_default_models_enabled (Annotated[bool, Strict(strict=True)])

• model_names (List[Annotated[str, Strict(strict=True)]])

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

base_url: StrictStr | None

header_names: List[StrictStr]

is_default_models_enabled: StrictBool

model_names: List[StrictStr]

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of NvidiaNimConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of NvidiaNimConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class OpenAiConfig(*, is_function_calling_enabled: Annotated[bool, Strict(strict=True)], provider: Annotated[str, Strict(strict=True)], has_api_key: Annotated[bool, Strict(strict=True)], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for an OpenAI LLM integration.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)])

• provider (Annotated[str, Strict(strict=True)])

• has_api_key (Annotated[bool, Strict(strict=True)])

• additional_properties (Dict[str, Any])

is_function_calling_enabled: StrictBool

provider: StrictStr

has_api_key: StrictBool

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of OpenAiConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of OpenAiConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class PaginationMetadata(*, next_cursor: Annotated[str, Strict(strict=True)] | None = None, has_more: Annotated[bool, Strict(strict=True)])

Bases: BaseModel

Cursor-based pagination metadata. Use next_cursor in the subsequent request’s cursor query parameter.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• next_cursor (Annotated[str, Strict(strict=True)] | None)

• has_more (Annotated[bool, Strict(strict=True)])

next_cursor: StrictStr | None

has_more: StrictBool

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of PaginationMetadata from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of PaginationMetadata from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class UpdateAgentRequestPresetInput(*, name: Annotated[str, Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)], description: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=1024)])] | None = None, config: Dict[str, Any])

Bases: BaseModel

Write shape for an agent request preset on update. Matched by name: existing names update in place (preserving id/timestamps), new names insert, removed names delete. Server-generated fields (id, created_at, updated_at) are not accepted on input.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• name (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])])

• description (Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=1024)])] | None)

• config (Dict[str, Any])

name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]

description: Annotated[str, Field(strict=True, max_length=1024)] | None

config: Dict[str, Any]

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of UpdateAgentRequestPresetInput from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of UpdateAgentRequestPresetInput from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class UpdateLlmConfig(*, provider: LlmIntegrationProvider | None = None, api_key: Annotated[str, Strict(strict=True)] | None = None, is_function_calling_enabled: Annotated[bool, Strict(strict=True)] | None = None, auth: CreateAwsBedrockAuth | None = None, base_url: Annotated[str, Strict(strict=True)] | None = None, headers: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, is_default_models_enabled: Annotated[bool, Strict(strict=True)] | None = None, model_names: List[Annotated[str, Strict(strict=True)]] | None = None, project_id: Annotated[str, Strict(strict=True)] | None = None, location: Annotated[str, Strict(strict=True)] | None = None, project_access_label: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Partial LLM config for PATCH. provider is immutable; if present it must match the stored value. Invalid provider/field combinations return 422. Provider-specific fields: - api_key, is_function_calling_enabled: all except AWS_BEDROCK, VERTEX_AI - auth: AWS_BEDROCK only - base_url: ANTHROPIC, CUSTOM, LITELLM, NVIDIA_NIM - headers: CUSTOM, LITELLM, NVIDIA_NIM - is_default_models_enabled: AWS_BEDROCK, CUSTOM, FIREWORKS, NVIDIA_NIM - model_names: AWS_BEDROCK, CUSTOM, FIREWORKS, LITELLM, NVIDIA_NIM - project_id, location, project_access_label: VERTEX_AI only

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• provider (LlmIntegrationProvider | None)

• api_key (Annotated[str, Strict(strict=True)] | None)

• is_function_calling_enabled (Annotated[bool, Strict(strict=True)] | None)

• auth (CreateAwsBedrockAuth | None)

• base_url (Annotated[str, Strict(strict=True)] | None)

• headers (Dict[str, Annotated[str, Strict(strict=True)]] | None)

• is_default_models_enabled (Annotated[bool, Strict(strict=True)] | None)

• model_names (List[Annotated[str, Strict(strict=True)]] | None)

• project_id (Annotated[str, Strict(strict=True)] | None)

• location (Annotated[str, Strict(strict=True)] | None)

• project_access_label (Annotated[str, Strict(strict=True)] | None)

provider: LlmIntegrationProvider | None

api_key: StrictStr | None

is_function_calling_enabled: StrictBool | None

auth: CreateAwsBedrockAuth | None

base_url: StrictStr | None

headers: Dict[str, StrictStr] | None

is_default_models_enabled: StrictBool | None

model_names: List[StrictStr] | None

project_id: StrictStr | None

location: StrictStr | None

project_access_label: StrictStr | None

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of UpdateLlmConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of UpdateLlmConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None

class VertexAiConfig(*, provider: Annotated[str, Strict(strict=True)], project_id: Annotated[str, Strict(strict=True)], location: Annotated[str, Strict(strict=True)], project_access_label: Annotated[str, Strict(strict=True)], additional_properties: Dict[str, Any] = {})

Bases: BaseModel

Config for a Google Vertex AI integration. Vertex stores no credentials: Arize accesses Vertex through the configured GCP project. All fields are returned on read.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

• provider (Annotated[str, Strict(strict=True)])

• project_id (Annotated[str, Strict(strict=True)])

• location (Annotated[str, Strict(strict=True)])

• project_access_label (Annotated[str, Strict(strict=True)])

• additional_properties (Dict[str, Any])

provider: StrictStr

project_id: StrictStr

location: StrictStr

project_access_label: StrictStr

additional_properties: Dict[str, Any]

classmethod provider_validate_enum(value)

Validates the enum

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_str() → str

Returns the string representation of the model using alias

Return type:

str

to_json() → str

Returns the JSON representation of the model using alias

Return type:

str

classmethod from_json(json_str: str) → Self | None

Create an instance of VertexAiConfig from a JSON string

Parameters:

json_str (str)

Return type:

Self | None

to_dict() → Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic’s self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

• Fields in self.additional_properties are added to the output dict.

Return type:

Dict[str, Any]

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of VertexAiConfig from a dict

Parameters:

obj (Dict[str, Any] | None)

Return type:

Self | None