# Custom Endpoint Object Structure (https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

Each endpoint in the `custom` array should have the following structure:

## Example

```yaml filename="Endpoint Object Structure"
endpoints:
  custom:
    # Example using Mistral AI API
    - name: 'Mistral'
      apiKey: '${YOUR_ENV_VAR_KEY}'
      baseURL: 'https://api.mistral.ai/v1'
      models:
        default: ['mistral-tiny', 'mistral-small', 'mistral-medium', 'mistral-large-latest']
      titleConvo: true
      titleTiming: 'immediate'
      titleModel: 'mistral-tiny'
      modelDisplayLabel: 'Mistral'
      # customParams:
      #   reasoningFormat: reasoning_object
      #   reasoningKey: reasoning_content
      # tokenConfig:
      #   mistral-large-latest:
      #     prompt: 2
      #     completion: 6
      #     context: 128000
      # addParams:
      #   safe_prompt: true # Mistral specific value for moderating messages
      # NOTE: For Mistral, it is necessary to drop the following parameters or you will encounter a 422 Error:
      dropParams: ['stop', 'user', 'frequency_penalty', 'presence_penalty']

    # Example using the native Anthropic Messages API
    - name: 'Claude-Compatible'
      provider: 'anthropic'
      apiKey: '${ANTHROPIC_API_KEY}'
      baseURL: 'https://api.anthropic.com'
      headers:
        anthropic-version: '2023-06-01'
      models:
        default: ['claude-sonnet-4-5', 'claude-opus-4-5']
        fetch: false
      titleConvo: true
      titleModel: 'claude-sonnet-4-5'
      modelDisplayLabel: 'Claude (Compatible)'
```

## name

**Key:**

<OptionTable
  options={[
    [
      'name',
      'String',
      'A unique name for the endpoint.',
      'Will be used as the "title" in the Endpoints Selector',
    ],
  ]}
/>

**Required**

**Example:**

```yaml filename="endpoints / custom / name"
name: 'Mistral'
```

## apiKey

**Key:**

<OptionTable
  options={[
    [
      'apiKey',
      'String (apiKey | "user_provided")',
      'Your API key for the service. Can reference an environment variable, or allow user to provide the value.',
      "It's highly recommended to use the env. variable reference for this field, i.e. `${YOUR_VARIABLE}`",
    ],
  ]}
/>

**Required**

**Example:**

```yaml filename="endpoints / custom / apiKey"
apiKey: '${MISTRAL_API_KEY}'
```

or

```yaml filename="endpoints / custom / apiKey"
apiKey: 'your_api_key'
```

or

```yaml filename="endpoints / custom / apiKey"
apiKey: 'user_provided'
```

When a custom endpoint is written through the administrator configuration API, LibreChat encrypts a literal `apiKey` at rest and returns only an `apiKeyPreview`. `${ENV_VAR}` references and `user_provided` remain readable passthrough values. For endpoints defined directly in `librechat.yaml`, prefer an environment reference as shown above.

## baseURL

**Key:**

<OptionTable
  options={[
    [
      'baseURL',
      'String (baseURL | "user_provided")',
      'Base URL for the API. Can reference an environment variable, or allow user to provide the value.',
      "It's highly recommended to use the env. variable reference for this field, i.e. `${YOUR_VARIABLE}`",
    ],
  ]}
/>

**Required**

**Example:**

```yaml filename="endpoints / custom / baseURL"
baseURL: 'https://api.mistral.ai/v1'
```

or

```yaml filename="endpoints / custom / baseURL"
baseURL: '${MISTRAL_BASE_URL}'
```

or

```yaml filename="endpoints / custom / baseURL"
baseURL: 'user_provided'
```

**Notes:**

- If the `baseURL` you set is the full completions endpoint, you can set the [directEndpoint](#directendpoint) field to `true` to use it directly.
  - This is necessary because the app appends "/chat/completions" or "/completion" to the `baseURL` by default.
- When using [`provider: anthropic`](#provider), set `baseURL` to the API root that the Anthropic SDK should call, such as `https://api.anthropic.com` or your gateway root. LibreChat uses the native Anthropic `/v1/messages` path for that provider.
- On OpenAI-compatible custom endpoints, model IDs containing `claude` use Claude document restrictions: PDFs and text documents are accepted, while non-PDF binary document types are skipped before the request is sent.

## provider

**Key:**

<OptionTable
  options={[
    [
      'provider',
      'String',
      'Routes a custom endpoint through a native provider client instead of the default OpenAI-compatible client.',
      'Currently supports `anthropic`.',
    ],
  ]}
/>

**Default:** omitted, which uses the OpenAI-compatible custom endpoint path.

**Supported Values:**

- **`"anthropic"`** - Uses the native Anthropic `/v1/messages` client with this endpoint's `baseURL`, `apiKey`, `headers`, `addParams`, `dropParams`, and `customParams.paramDefinitions`.

**Example:**

```yaml filename="endpoints / custom / provider"
endpoints:
  custom:
    - name: 'Claude-Compatible'
      provider: 'anthropic'
      apiKey: '${ANTHROPIC_API_KEY}'
      baseURL: 'https://api.anthropic.com'
      headers:
        anthropic-version: '2023-06-01'
      models:
        default:
          - 'claude-sonnet-4-5'
          - 'claude-opus-4-5'
        fetch: false
      titleConvo: true
      titleModel: 'claude-sonnet-4-5'
      modelDisplayLabel: 'Claude (Compatible)'
```

**Notes:**

- Use `provider: anthropic` for Anthropic itself or Anthropic-compatible gateways that speak the native Messages API.
- List models explicitly under `models.default`; OpenAI-style `models.fetch` is not used for native Anthropic custom endpoints.
- The provider implies Anthropic UI parameters unless you explicitly set a different `customParams.defaultParamsEndpoint`.
- Endpoints without `provider` keep the OpenAI-compatible behavior.

## iconURL

**Key:**

<OptionTable
  options={[
    [
      'iconURL',
      'String',
      'Image URL, public asset path, or built-in endpoint icon key to use as the endpoint icon.',
      '',
    ],
  ]}
/>

**Default:** `""`

**Example:**

```yaml filename="endpoints / custom / iconURL"
iconURL: https://github.com/danny-avila/LibreChat/raw/main/docs/assets/LibreChat.svg
```

or reuse a built-in endpoint icon:

```yaml filename="endpoints / custom / iconURL"
iconURL: openAI
```

**Notes:**

- Do not set a custom endpoint `name` to a built-in endpoint name just to reuse an icon. Custom endpoint names must be unique and should not use default endpoint values such as:
  - "openAI" | "azureOpenAI" | "google" | "anthropic" | "assistants" | "azureAssistants" | "agents" | "bedrock"
- To use a project-included endpoint icon, keep the custom endpoint `name` unique and set `iconURL` to one of the built-in endpoint keys instead.
  - "openAI" | "azureOpenAI" | "google" | "anthropic" | "assistants" | "azureAssistants" | "agents" | "bedrock"
- To use a custom image, set `iconURL` to an image URL or a path served by LibreChat, such as `/assets/my-icon.svg`.
- There are also "known endpoints" (case-insensitive), which have icons provided. If your endpoint `name` matches the following names, you should omit this field:
  - "Anyscale"
  - "APIpie"
  - "Cohere"
  - "Deepseek"
  - "Fireworks"
  - "groq"
  - "Helicone"
  - "Huggingface"
  - "Mistral"
  - "MLX"
  - "Moonshot"
  - "ollama"
  - "OpenRouter"
  - "Perplexity"
  - "Qwen"
  - "ShuttleAI"
  - "together.ai"
  - "Unify"
  - "xai"

## models

**Key:**

<OptionTable options={[['models', 'Object', 'Configuration for models.', '']]} />

**Required**

**Properties:**

### default

**Key:**

<OptionTable
  options={[
    [
      'default',
      'Array of Strings',
      'An array of strings indicating the default models to use.',
      'If fetching models fails, these defaults are used as a fallback.',
    ],
  ]}
/>

**Required**

**Example:**

```yaml filename="endpoints / custom / models / default"
default:
  - 'mistral-tiny'
  - 'mistral-small'
  - 'mistral-medium'
```

### fetch

**Key:**

<OptionTable
  options={[
    [
      'fetch',
      'Boolean',
      'When set to `true`, attempts to fetch a list of models from the API.',
      'May cause slowdowns during initial use of the app if the response is delayed. Defaults to `false`.',
    ],
  ]}
/>

**Default:** `false`

**Example:**

```yaml filename="endpoints / custom / models / fetch"
fetch: true
```

### userIdQuery

**Key:**

<OptionTable
  options={[
    [
      'userIdQuery',
      'Boolean',
      'When set to `true`, adds the LibreChat user ID as a query parameter to the API models request.',
      '',
    ],
  ]}
/>

**Default:** `false`

**Example:**

```yaml filename="endpoints / custom / models / userIdQuery"
userIdQuery: true
```

## titleConvo

**Key:**

<OptionTable
  options={[['titleConvo', 'Boolean', 'Enables title conversation when set to `true`.', '']]}
/>

**Default:** `false`

**Example:**

```yaml filename="endpoints / custom / titleConvo"
titleConvo: true
```

## titleTiming

**Key:**

<OptionTable
  options={[
    [
      'titleTiming',
      'String',
      'Controls when conversation titles are generated. Valid values: "immediate" or "final".',
      'Defaults to "immediate".',
    ],
  ]}
/>

**Default:** `"immediate"`

**Available Values:**

- **`"immediate"`** - Generates the title as soon as the request starts, in parallel with the model response, using the user's first message.
- **`"final"`** - Defers title generation until the full response completes. This preserves the legacy behavior.

**Example:**

```yaml filename="endpoints / custom / titleTiming"
titleTiming: 'final'
```

## titleMethod

**Key:**

<OptionTable
  options={[
    [
      'titleMethod',
      'String',
      'Controls the method used for generating conversation titles.',
      'Valid values: "completion" (default), "structured", "functions" (legacy alias for "structured")',
    ],
  ]}
/>

**Default:** `"completion"`

**Available Methods:**

- **`"completion"`** - Uses standard completion API without tools/functions. Compatible with most LLMs.
- **`"structured"`** - Uses structured output for title generation. Requires provider/model support.
- **`"functions"`** - Legacy alias for "structured". Functionally identical.

**Example:**

```yaml filename="endpoints / custom / titleMethod"
titleMethod: 'completion'
```

## titleModel

**Key:**

<OptionTable
  options={[
    [
      'titleModel',
      'String',
      'Specifies the model to use for titles.',
      'Defaults to "gpt-3.5-turbo" if omitted. May cause issues if "gpt-3.5-turbo" is not available. You can also dynamically use the current conversation model by setting it to "current_model".',
    ],
  ]}
/>

**Default:** `"gpt-3.5-turbo"`

**Example:**

```yaml filename="endpoints / custom / titleModel"
titleModel: 'mistral-tiny'
```

```yaml filename="endpoints / custom / titleModel"
titleModel: 'current_model'
```

## titlePrompt

**Key:**

<OptionTable
  options={[
    [
      'titlePrompt',
      'String',
      'Custom prompt for title generation. Must include {convo} placeholder.',
      'Allows full control over how titles are generated.',
    ],
  ]}
/>

**Default:**

```
Analyze this conversation and provide:
1. The detected language of the conversation
2. A concise title in the detected language (5 words or less, no punctuation or quotation)

{convo}
```

**Notes:**

- Must always include the `{convo}` placeholder
- The `{convo}` placeholder will be replaced with the formatted conversation

**Example:**

```yaml filename="endpoints / custom / titlePrompt"
titlePrompt: "Create a brief, descriptive title for the following conversation:\n\n{convo}\n\nTitle:"
```

## titlePromptTemplate

**Key:**

<OptionTable
  options={[
    [
      'titlePromptTemplate',
      'String',
      'Template for formatting the conversation content that replaces {convo} in titlePrompt.',
      'Must include {input} and {output} placeholders.',
    ],
  ]}
/>

**Default:** `"User: {input}\nAI: {output}"`

**Notes:**

- Must include both `{input}` and `{output}` placeholders
- Controls how the conversation is formatted when inserted into `titlePrompt`

**Example:**

```yaml filename="endpoints / custom / titlePromptTemplate"
titlePromptTemplate: "Human: {input}\n\nAssistant: {output}"
```

## titleEndpoint

**Key:**

<OptionTable
  options={[
    [
      'titleEndpoint',
      'String',
      'Specifies an alternative endpoint to use for title generation.',
      'Allows using a different model/endpoint for titles.',
    ],
  ]}
/>

**Default:** Uses the current custom endpoint

**Accepted Values:**

- `openAI`
- `azureOpenAI`
- `google`
- `anthropic`
- `bedrock`
- Another custom endpoint name

**Example:**

```yaml filename="endpoints / custom / titleEndpoint"
# Use a different custom endpoint for titles
endpoints:
  custom:
    - name: 'my-chat-endpoint'
      apiKey: '${CHAT_API_KEY}'
      baseURL: 'https://api.example.com/v1/chat'
      models:
        default: ['gpt-4']
      titleEndpoint: 'my-title-endpoint'

    - name: 'my-title-endpoint'
      apiKey: '${TITLE_API_KEY}'
      baseURL: 'https://api.example.com/v1/title'
      models:
        default: ['gpt-3.5-turbo']
```

## modelDisplayLabel

**Key:**

<OptionTable
  options={[
    [
      'modelDisplayLabel',
      'String',
      'The label displayed in messages next to the Icon for the current AI model.',
      'The display order is: 1. Custom name set via preset (if available), 2. Label derived from the model name (if applicable), 3. This value is used if the above are not specified. Defaults to "AI".',
    ],
  ]}
/>

**Default:** `"AI"`

**Example:**

```yaml filename="endpoints / custom / modelDisplayLabel"
modelDisplayLabel: 'Mistral'
```

## addParams

**Key:**

<OptionTable
  options={[
    [
      'addParams',
      'Object/Dictionary',
      'Adds additional parameters to requests. Values can be strings, numbers, booleans, arrays, or nested objects. Supports provider tool toggles such as `web_search: true` and Google `url_context: true`.',
      'Adds/Overrides parameters. Useful for specifying API-specific options.',
    ],
  ]}
/>

**Example:**

```yaml filename="endpoints / custom / addParams"
addParams:
  safe_prompt: true
  max_tokens: 2048
```

**Notes:**

- The `addParams` field allows you to include additional parameters that are not part of the default payload(see the ["Default Parameters"](/docs/configuration/librechat_yaml/object_structure/default_params) section). This is particularly useful for API-specific options.

## dropParams

**Key:**

<OptionTable
  options={[
    [
      'dropParams',
      'Array/List of Strings',
      'Removes default parameters from requests.',
      'Excludes specified default parameters. Useful for APIs that do not accept or recognize certain parameters.',
    ],
  ]}
/>

**Example:**

```yaml filename="endpoints / custom / dropParams"
dropParams:
  - 'stop'
  - 'user'
  - 'frequency_penalty'
  - 'presence_penalty'
```

**Note:**

- The `dropParams` field allows you to remove ["Default Parameters"](/docs/configuration/librechat_yaml/object_structure/default_params) that are sent with every request. This is helpful when working with APIs that do not accept or recognize certain parameters.

## customParams

**Key:**

<OptionTable
  options={[
    [
      'customParams',
      'Object/Dictionary',
      'Defines custom endpoint behavior and settings metadata that are not part of the provider request body.',
      'Used for endpoint-specific configuration such as reasoning parameter shape.',
    ],
  ]}
/>

**Sub-keys:**

<OptionTable
  options={[
    [
      'defaultParamsEndpoint',
      'String',
      'Endpoint defaults used for request parameter metadata. Defaults to `custom`. When `provider: anthropic` is set and this field is omitted, LibreChat uses the Anthropic parameter set.',
      'defaultParamsEndpoint: custom',
    ],
    [
      'reasoningFormat',
      'String',
      'Controls how reasoning parameters are sent to OpenAI-compatible custom endpoints. Valid values: `reasoning_effort`, `reasoning_object`, `disabled`.',
      'reasoningFormat: reasoning_object',
    ],
    [
      'reasoningKey',
      'String',
      'Controls which response key is read for provider reasoning content. Valid values: `reasoning` or `reasoning_content`.',
      'reasoningKey: reasoning_content',
    ],
    [
      'includeReasoningContent',
      'Boolean',
      'Replays provider `reasoning_content` within tool-call turns for OpenAI-compatible custom endpoints that require it.',
      'includeReasoningContent: true',
    ],
    [
      'includeReasoningHistory',
      'Boolean',
      'Reconstructs `reasoning_content` from persisted conversation history across turns. Implies `includeReasoningContent`.',
      'includeReasoningHistory: true',
    ],
    [
      'paramDefinitions',
      'Array/List',
      'Custom setting definitions for this endpoint.',
      'See default parameter definitions.',
    ],
  ]}
/>

**Reasoning Formats:**

- **`reasoning_effort`** - Sends the legacy `reasoning_effort` parameter.
- **`reasoning_object`** - Sends a `reasoning` object, such as `{ effort, summary }`, for providers that follow the newer OpenAI-compatible shape.
- **`disabled`** - Suppresses reasoning parameters even when a user or model spec selects reasoning.

**Reasoning replay:**

- Use `includeReasoningContent: true` for OpenAI-compatible providers that require assistant `reasoning_content` to be replayed during tool-call turns.
- Use `includeReasoningHistory: true` only for providers that also require `reasoning_content` reconstructed from persisted history across later turns, such as some Xiaomi MiMo or Kimi-compatible gateways.

**Anthropic provider note:**

Use [`provider: anthropic`](#provider) when the custom endpoint should use the native Anthropic Messages API. Use `customParams.defaultParamsEndpoint: anthropic` without `provider` only when you still need the OpenAI-compatible custom endpoint path but want Anthropic-style parameter metadata and request adaptation.

**Example:**

```yaml filename="endpoints / custom / customParams"
customParams:
  reasoningFormat: reasoning_object
  reasoningKey: reasoning_content
  includeReasoningContent: true
```

## tokenConfig

**Key:**

<OptionTable
  options={[
    [
      'tokenConfig',
      'Object/Dictionary',
      'Defines model-specific context windows and per-million-token rates for this custom endpoint.',
      'Used by context usage, visible cost breakdowns, balance transactions, and multi-endpoint agent billing.',
    ],
  ]}
/>

Each key is a model name. Each model entry supports:

<OptionTable
  options={[
    ['prompt', 'Number', 'Prompt/input token rate per million tokens.', 'Required'],
    ['completion', 'Number', 'Completion/output token rate per million tokens.', 'Required'],
    ['context', 'Number', 'Maximum context window for the model.', 'Required'],
    ['cacheRead', 'Number', 'Cached input read rate per million tokens.', 'Optional'],
    ['cacheWrite', 'Number', 'Cached input write rate per million tokens.', 'Optional'],
  ]}
/>

**Example:**

```yaml filename="endpoints / custom / tokenConfig"
tokenConfig:
  gpt-4o-mini:
    prompt: 0.15
    completion: 0.6
    context: 128000
    cacheRead: 0.075
    cacheWrite: 0.15
```

**Notes:**

- Rates are expressed per million tokens in USD before any [`interface.currency`](/docs/configuration/librechat_yaml/object_structure/interface#currency) conversion is applied for display.
- The model name must match the model value sent through the custom endpoint.
- For Agents using multiple endpoints, the matching endpoint/model token config is used when recording usage and cost.

## headers

**Key:**

<OptionTable
  options={[
    [
      'headers',
      'Object/Dictionary',
      'Adds additional headers to requests. All header values must be strings. Supports dynamic user field substitution with `{{LIBRECHAT_USER_*}}`, request body placeholders with `{{LIBRECHAT_BODY_*}}`, and environment variables with `${ENV_VAR}`.',
      'The `headers` object specifies custom headers for requests. Useful for authentication and setting content types.',
    ],
  ]}
/>

**Example:**

```yaml filename="endpoints / custom / headers"
headers:
  x-api-key: '${ENVIRONMENT_VARIABLE}'
  Content-Type: 'application/json'
  X-User-ID: '{{LIBRECHAT_USER_ID}}'
  X-User-Email: '{{LIBRECHAT_USER_EMAIL}}'
```

**Note:** Supports dynamic environment variable values, which use the format: `"${VARIABLE_NAME}"`.

At the final outbound resolution step, recognized `{{LIBRECHAT_USER_*}}`, `{{LIBRECHAT_BODY_*}}`, and `{{LIBRECHAT_OPENID_*}}` placeholders without a value become empty strings instead of being forwarded as template text. Unknown placeholder names remain unchanged so configuration typos are visible.

When `models.fetch: true` is used, these headers are also resolved and forwarded to the model-list request for admin-controlled base URLs. A configured `Authorization` header takes precedence over the endpoint `apiKey` fallback, which is useful for auth-aware proxies that return per-user model lists. If `baseURL: "user_provided"` is configured, LibreChat does not forward configured header templates to the user-provided destination. For `provider: anthropic`, headers are forwarded through the native Anthropic client instead of the OpenAI-compatible client.

**Available User Field Placeholders:**

| Placeholder                           | User Field         | Type             | Description                                                 |
| ------------------------------------- | ------------------ | ---------------- | ----------------------------------------------------------- |
| `{{LIBRECHAT_USER_ID}}`               | `id`               | String           | User's unique identifier                                    |
| `{{LIBRECHAT_USER_NAME}}`             | `name`             | String           | User's display name                                         |
| `{{LIBRECHAT_USER_USERNAME}}`         | `username`         | String           | User's username                                             |
| `{{LIBRECHAT_USER_EMAIL}}`            | `email`            | String           | User's email address                                        |
| `{{LIBRECHAT_USER_PROVIDER}}`         | `provider`         | String           | Authentication provider (e.g., "email", "google", "github") |
| `{{LIBRECHAT_USER_ROLE}}`             | `role`             | String           | User's role (e.g., "user", "admin")                         |
| `{{LIBRECHAT_USER_GOOGLEID}}`         | `googleId`         | String           | Google account ID                                           |
| `{{LIBRECHAT_USER_FACEBOOKID}}`       | `facebookId`       | String           | Facebook account ID                                         |
| `{{LIBRECHAT_USER_OPENIDID}}`         | `openidId`         | String           | OpenID account ID                                           |
| `{{LIBRECHAT_USER_SAMLID}}`           | `samlId`           | String           | SAML account ID                                             |
| `{{LIBRECHAT_USER_LDAPID}}`           | `ldapId`           | String           | LDAP account ID                                             |
| `{{LIBRECHAT_USER_GITHUBID}}`         | `githubId`         | String           | GitHub account ID                                           |
| `{{LIBRECHAT_USER_DISCORDID}}`        | `discordId`        | String           | Discord account ID                                          |
| `{{LIBRECHAT_USER_APPLEID}}`          | `appleId`          | String           | Apple account ID                                            |
| `{{LIBRECHAT_USER_EMAILVERIFIED}}`    | `emailVerified`    | Boolean → String | Email verification status ("true" or "false")               |
| `{{LIBRECHAT_USER_TWOFACTORENABLED}}` | `twoFactorEnabled` | Boolean → String | 2FA status ("true" or "false")                              |
| `{{LIBRECHAT_USER_TERMSACCEPTED}}`    | `termsAccepted`    | Boolean → String | Terms acceptance status ("true" or "false")                 |
| `{{LIBRECHAT_USER_TERMSACCEPTEDAT}}`  | `termsAcceptedAt`  | Date → String    | Terms acceptance timestamp                                  |

Agent model requests also support `{{LIBRECHAT_USER_TENANT_ID}}` and `{{LIBRECHAT_USER_TENANTID}}` in custom endpoint headers. Both aliases use the authoritative request-scoped tenant rather than a potentially stale user record, apply to root Agents, Subagents, and custom summarization calls, and resolve to an empty string when no tenant is present. They are not general user-field placeholders for non-Agent template consumers.

**Available Request Body Placeholders:**

| Placeholder                          | Body Field        | Type   | Description                     |
| ------------------------------------ | ----------------- | ------ | ------------------------------- |
| `{{LIBRECHAT_BODY_CONVERSATIONID}}`  | `conversationId`  | String | Current conversation identifier |
| `{{LIBRECHAT_BODY_PARENTMESSAGEID}}` | `parentMessageId` | String | Parent message identifier       |
| `{{LIBRECHAT_BODY_MESSAGEID}}`       | `messageId`       | String | Current message identifier      |

**Example using request body placeholders:**

```yaml filename="endpoints / custom / headers with body placeholders"
headers:
  X-Conversation-ID: '{{LIBRECHAT_BODY_CONVERSATIONID}}'
  X-Parent-Message-ID: '{{LIBRECHAT_BODY_PARENTMESSAGEID}}'
  X-Message-ID: '{{LIBRECHAT_BODY_MESSAGEID}}'
```

## directEndpoint

**Key:**

<OptionTable
  options={[
    [
      'directEndpoint',
      'Boolean',
      'When set to `true`, treats the configured `baseURL` as the completions endpoint to be used',
      '',
    ],
  ]}
/>

**Default:** `false`

**Example:**

```yaml filename="endpoints / custom / directEndpoint"
directEndpoint: true
```

## titleMessageRole

- **Options**: `"system"` | `"user"` | `"assistant"`

**Key:**

<OptionTable
  options={[
    [
      'titleMessageRole',
      'String',
      'Specifies the role value to use in the message payload for title generation. Must be one of: `"system"`, `"user"`, `"assistant"`.',
      'Defaults to "system" if omitted. May cause issues if "system" is not a valid value, which is sometimes the case for single message payloads, as it is for title generation.',
    ],
  ]}
/>

**Default:** `"system"`

**Example:**

```yaml filename="endpoints / custom / titleMessageRole"
titleMessageRole: 'user'
```