# Configuration Data Structures in Continue: A Deep Dive into `core/config/types.ts`

> Explore Continue's four-layer TypeScript configuration hierarchy from SerializedContinueConfig to ContinueConfig for managing IDE settings. Understand core config types.

- Repository: [Continue/continue](https://github.com/continuedev/continue)
- Tags: deep-dive
- Published: 2026-06-18

---

**Continue uses a four-layer hierarchy of TypeScript interfaces—from `SerializedContinueConfig` for raw JSON parsing to `ContinueConfig` for runtime execution—to manage IDE settings in [`continue.json`](https://github.com/continuedev/continue/blob/main/continue.json) files.**

Continue, the open-source AI coding assistant, organizes its settings through strictly-typed configuration data structures defined in [`core/config/types.ts`](https://github.com/continuedev/continue/blob/main/core/config/types.ts). These interfaces transform user-edited [`continue.json`](https://github.com/continuedev/continue/blob/main/continue.json) files into runtime-ready objects that power LLM interactions, context providers, and embeddings across VS Code and JetBrains IDEs.

## The Four-Layer Configuration Hierarchy

The codebase maintains distinct interfaces for each stage of the configuration lifecycle, ensuring type safety from file system to execution.

**SerializedContinueConfig** represents the direct mapping of the JSON file a user edits. Located at [`core/config/types.ts#L1150`](https://github.com/continuedev/continue/blob/main/core/config/types.ts#L1150), this interface defines all fields as optional to accommodate partial configurations while preserving the exact shape supplied by the user.

**Config** serves as a user-friendly wrapper that exposes the most common options—including models, slash commands, and context providers—at [`core/config/types.ts#L1175`](https://github.com/continuedev/continue/blob/main/core/config/types.ts#L1175). This simplified view abstracts away implementation details while maintaining full TypeScript intellisense.

**ContinueConfig** constitutes the concrete configuration actually used by the inference engine. Defined at [`core/config/types.ts#L1220`](https://github.com/continuedev/continue/blob/main/core/config/types.ts#L1220), this structure contains all optional fields filled with defaults and instantiated helper objects such as `ILLM` instances for model communication.

**BrowserSerializedContinueConfig** handles UI-specific serialization at [`core/config/types.ts#L1245`](https://github.com/continuedev/continue/blob/main/core/config/types.ts#L1245). This shape mirrors the raw config but drops runtime-only objects before transmission to the web-based interface.

**ConfigMergeType** and **ContinueRcJson** control merge semantics at [`core/config/types.ts#L1265`](https://github.com/continuedev/continue/blob/main/core/config/types.ts#L1265), determining whether a [`continue.rc.json`](https://github.com/continuedev/continue/blob/main/continue.rc.json) file merges with or overwrites the base configuration.

## Key Configuration Sub-Structures

Nested within the main hierarchy, specialized interfaces define specific functional areas:

- **ModelDescription** – Configures LLM connections with `title`, `provider`, `model`, and optional `apiKey` fields for provider authentication.
- **ContextProviderDescription** – Defines data sources such as `codebase`, `gitlab-mr`, and `search` with metadata including title, description, and type parameters.
- **EmbeddingsProviderDescription** – Specifies vector-store configurations for semantic code search and retrieval.
- **RerankerDescription** – Configures ranking algorithms that prioritize relevant context chunks.
- **ExperimentalConfig** – Houses optional features including custom quick actions, text-to-speech (TTS), and Chromium crawling capabilities.

## How Configuration Is Loaded and Resolved

The transformation from raw JSON to executable configuration occurs in **[`extensions/cli/src/configLoader.ts`](https://github.com/continuedev/continue/blob/main/extensions/cli/src/configLoader.ts)**. This module orchestrates the resolution pipeline:

1. **Read** the base [`continue.json`](https://github.com/continuedev/continue/blob/main/continue.json) file into a `Config` object
2. **Locate** and parse the optional [`continue.rc.json`](https://github.com/continuedev/continue/blob/main/continue.rc.json) file
3. **Merge** configurations according to the `ConfigMergeType` behavior (`"merge"` vs `"overwrite"`)
4. **Resolve** the final `ContinueConfig` by instantiating LLM classes, embeddings providers, and other service objects

```typescript
// Conceptual flow based on extensions/cli/src/configLoader.ts
import { Config, ContinueConfig } from "../../core/config/types";

async function loadContinueConfig(): Promise<ContinueConfig> {
  const raw: Config = await readUserConfigFile();          // reads continue.json
  const rc: Partial<Config> = await readRcFile();          // optional .rc merge
  const merged = mergeConfig(raw, rc);                     // respects ConfigMergeType
  return resolveRuntimeConfig(merged);                     // creates ILLM instances, etc.
}

```

The `resolveRuntimeConfig` helper performs the critical transformation from static descriptions to live service instances, enabling the rest of the codebase to interact with configured providers through uniform interfaces.

## Practical Configuration Examples

### Defining a Simple continue.json

All fields map directly to the `SerializedContinueConfig` interface:

```json
{
  "models": [
    {
      "title": "OpenAI GPT-4",
      "provider": "openai",
      "model": "gpt-4",
      "apiKey": "YOUR_API_KEY"
    }
  ],
  "slashCommands": [
    { "name": "explain", "description": "Explain selected code" }
  ],
  "contextProviders": [
    { "name": "codebase", "params": {} }
  ]
}

```

### Accessing Resolved Configuration in a Plugin

Plugins receive the fully-resolved `ContinueConfig` through the SDK:

```typescript
import type { ContinueConfig } from "core/config/types";

export function myPlugin(sdk: ContinueSDK) {
  const cfg: ContinueConfig = sdk.config;   // fully-resolved config
  console.log("LLM model:", cfg.models[0].model);
  console.log("Embedding provider:", cfg.embeddingsProvider.provider);
}

```

### Extending with a Custom LLM

The `Config` interface supports mixing standard `ModelDescription` objects with `CustomLLM` implementations:

```typescript
import type { CustomLLM } from "core/config/types";

const myCustomLLM: CustomLLM = {
  options: { model: "my-llm", streamChat: async* () => {} },
  streamChat: async function* (messages, signal, opts, fetch) {
    // custom call logic …
    yield "partial answer";
  }
};

export const config: Config = {
  models: [myCustomLLM],
  // …other fields…
};

```

## Summary

- **Configuration data structures in continuedev/continue** follow a strict hierarchy from `SerializedContinueConfig` (raw JSON) to `ContinueConfig` (runtime objects).
- **Core definitions** live in [`core/config/types.ts`](https://github.com/continuedev/continue/blob/main/core/config/types.ts), with line-specific interfaces at L1150, L1175, L1220, and L1245.
- **Resolution logic** resides in [`extensions/cli/src/configLoader.ts`](https://github.com/continuedev/continue/blob/main/extensions/cli/src/configLoader.ts), handling deep-merging of `.rc` files and instantiation of service objects.
- **UI state management** occurs in [`gui/src/redux/slices/configSlice.ts`](https://github.com/continuedev/continue/blob/main/gui/src/redux/slices/configSlice.ts), bridging the gap between runtime configuration and the web interface.
- **Merge behavior** is controlled by `ConfigMergeType`, allowing granular control over configuration inheritance.

## Frequently Asked Questions

### What is the difference between SerializedContinueConfig and ContinueConfig?

`SerializedContinueConfig` represents the raw, user-edited JSON with all fields optional, while `ContinueConfig` is the fully-resolved runtime version with defaults applied and actual class instances (like `ILLM` objects) instantiated. The transformation occurs in [`extensions/cli/src/configLoader.ts`](https://github.com/continuedev/continue/blob/main/extensions/cli/src/configLoader.ts) through the `resolveRuntimeConfig` function.

### How does Continue handle merging of continue.rc.json files?

Continue reads the base [`continue.json`](https://github.com/continuedev/continue/blob/main/continue.json) and optional [`continue.rc.json`](https://github.com/continuedev/continue/blob/main/continue.rc.json), then applies the `ConfigMergeType` behavior defined in `core/config/types.ts#L1265`. If set to `"merge"`, configurations are deeply combined; if `"overwrite"`, the RC file replaces the base configuration entirely.

### Where are the configuration TypeScript interfaces defined?

All configuration interfaces—including `SerializedContinueConfig`, `Config`, `ContinueConfig`, and `BrowserSerializedContinueConfig`—are centrally defined in [`core/config/types.ts`](https://github.com/continuedev/continue/blob/main/core/config/types.ts). This single source of truth ensures consistency across the CLI, GUI, and extension layers.

### Can I mix standard ModelDescription objects with custom LLM implementations?

Yes. The `Config` interface explicitly permits mixing native `ModelDescription` objects with `CustomLLM` implementations in the models array. This allows users to combine standard providers (OpenAI, Anthropic) with custom streaming implementations within the same configuration file.