Back
How to connect Continue.dev to FastRouter's model catalog

How to connect Continue.dev to FastRouter's model catalog

Connect Continue.dev to FastRouter through an OpenAI-compatible gateway. Configure model IDs, validate chat, and troubleshoot authentication and routing errors.

F
FastRouter Team
12 Min Read|Published

Instead of maintaining separate provider connections in Continue, Continue.dev can connect to FastRouter through its OpenAI-compatible gateway, with the desired model IDs configured. FastRouter provides the routing layer; Continue supplies the editor interface and model configuration.

TL;DR

  • Continue.dev connects to FastRouter with Continue's OpenAI provider, the gateway API base, an API key, and exact model IDs.
  • FastRouter fits enterprise teams that need centralized LLM routing, automatic failover, and usage governance.
  • Chat should come first; streaming and model behavior should be validated before autocomplete or tool-dependent workflows are added.
  • Gateway access does not replace Continue configuration: the models the editor workflow needs should be selected and tested.

Why this matters

An editor integration and a model gateway solve different problems. Continue connects the coding workflow to a model. The gateway manages access and routing behind that connection. Keeping those responsibilities separate makes configuration errors easier to diagnose.

FastRouter is best for enterprise development teams that need centralized LLM routing and usage governance. Its OpenAI-compatible interface provides the connection point for this workflow. Compatibility at that interface does not establish that every model supports every editor feature.

For a 2026 deployment, connection validation should be separated from capability validation. First, Continue should be proven able to authenticate and receive a response. Then the capabilities developers actually need should be tested: streaming, repository context, structured edits, or tool execution.

The benefit is a shared gateway connection rather than a collection of direct-provider credentials. The trade-off is another configuration boundary: the editor, gateway, and selected model must agree on the request format and supported behavior.

Before starting

  • Continue should be installed, and its active configuration located. This guide uses Continue's YAML configuration format. Which configuration the installed extension loads should be confirmed before editing; changing an inactive file produces no visible change.
  • Gateway credentials and connection details should be prepared. An authorized API key, the OpenAI-compatible API base, and an exact model ID from the gateway's current documentation or account are needed. The key should stay out of repository files and shared screenshots.
  • Model capabilities should be checked, not just catalog membership. A model listed in the catalog is not automatically suitable for autocomplete, tool execution, or every editing operation. 1 chat model entry should be the starting point, with that role validated before expansion.

The setup gotcha is the API base. Continue needs the API base expected by its OpenAI provider, not a website address or a complete chat-completions request URL. The documented value should be copied rather than constructed from the brand's domain.

For a 2026 rollout record, the Continue extension version, selected model ID, and configuration owner should be captured. These are deployment records, not credentials. They let another engineer reproduce the integration without copying a secret.

Gateway connection

  1. An API key authorized for the intended gateway access should be obtained and stored using the organization's approved secret-handling method.
  2. The gateway's documented OpenAI-compatible API base should be copied, preserving the documented path and version segment.
  3. The exact model ID intended for use should be copied, treated as an API identifier, not a display name.
  4. The development environment should be checked for the ability to reach the gateway, including any organization-specific proxy or outbound-network requirements.

The connection settings have separate jobs:

Configuration field

Purpose

Common mistake

provider

Selects Continue's request adapter

Selecting a direct-provider adapter for a gateway connection

apiBase

Sets the OpenAI-compatible API base

Entering a website address or a complete request endpoint

apiKey

Supplies gateway authentication

Using a credential intended for a different service

model

Identifies the requested model

Copying a display label instead of the exact API identifier

roles

Declares the Continue workflow for that entry

Assigning capabilities before validating them

An upstream provider credential should not substitute for the gateway key unless the gateway's documented authentication flow explicitly requires it. BYOK arrangements and gateway authentication are separate concerns; each should be configured according to the applicable instructions.

Expected result: an authorized credential, a documented API base, and an exact model ID are in place. No guessed endpoint or model alias remains in the setup.

Continue configuration

Continue's YAML configuration supports model entries with an OpenAI provider and a custom API base. The relevant keys are name, provider, model, apiBase, apiKey, and roles. These are configuration fields, not dashboard button labels.

  1. Open Continue's active YAML configuration in the editor. It should be backed up before changes are made.
  2. Locate the models list. Unrelated configuration and existing entries should be preserved.
  3. Add a model entry with provider set to openai and roles containing chat.
  4. Set apiBase, apiKey, and model to the verified connection values. name can hold a recognizable local label.
  5. Save the configuration and reload the extension if the installed version requires it. The new chat model should be selected in Continue.

The following Python helper generates a YAML-compatible model entry from supplied values. It prints only the entry to merge into the existing models list; it does not overwrite the configuration.

1import getpass
2import json
3
4name = input("Local model label: ").strip()
5api_base = input("Documented gateway API base: ").strip()
6model = input("Exact gateway model ID: ").strip()
7api_key = getpass.getpass("Gateway API key: ").strip()
8
9values = {
10 "name": name,
11 "provider": "openai",
12 "model": model,
13 "apiBase": api_base,
14 "apiKey": api_key,
15}
16
17if not all(values.values()):
18 raise SystemExit("Every connection field must be populated.")
19
20for index, (key, value) in enumerate(values.items()):
21 prefix = " - " if index == 0 else " "
22 print(f"{prefix}{key}: {json.dumps(value)}")
23print(" roles:")
24print(" - chat")

JSON-quoted strings are valid YAML strings, so the helper quotes punctuation-sensitive values rather than relying on manual escaping. The output should be pasted beneath the existing models key, matching the surrounding indentation.

The generated output contains the credential. This helper should run only in a private local session; its output should not be captured in shared logs, and the resulting configuration should not be committed. If the installed Continue version supports a documented secret-reference mechanism, that mechanism should be used instead of a literal key.

Expected result: Continue loads the entry without a configuration error, and the configured chat model appears as a selectable option. Appearance in the selector proves configuration loading, not successful authentication.

Request validation

The request path should be validated before a large repository task is tested. A short prompt separates connection problems from context size, tool behavior, and code-editing complexity.

  1. The newly configured chat model should be selected. A plain-text request asking for a short explanation of a familiar programming concept should be sent.
  2. The response should complete. If streaming is enabled, it should arrive without a parsing error or premature termination.
  3. A second request referencing a small, non-sensitive code selection should be sent. The answer should address the selected code rather than answer generically.
  4. The available editor logs and gateway usage records should be reviewed. The requested model and outcome should be checked without recording prompt content or credentials unnecessarily.

These 2 test prompts serve as a minimum smoke test: one plain-text request and one code-context request. This is a recommended validation sequence, not a performance benchmark.

The connection has three boundaries: the editor sends the request, the gateway handles access and routing, and the model returns output. The boundary that failed should be troubleshot instead of changing every setting simultaneously.

![Request flow from the editor through the gateway to the model](https://gwvckixiegkllthleuyt.supabase.co/storage/v1/object/public/workspace-article-images-public/41d4e785-37c5-43ba-a980-40d8b14631b6/body-198cf6bcf51da22fe5d7c6eabbfd2a16.jpg)

Validate the connection before testing advanced editor behavior.

For a 2026 acceptance check, the observed outcome of each prompt and the configuration used should be recorded. The integration should not be labeled production-ready solely because a model appears in the selector.

Expected result: both requests return usable responses through the configured gateway connection. Any remaining failure has a specific location: configuration loading, authentication, model selection, or response handling.

Model selection updates

A second workflow is useful when a team wants to compare models without changing the gateway connection. The same connection settings should stay in place, with another explicitly configured model entry added.

  1. The working entry within the models list should be copied.
  2. name should change to a distinct local label and model to another verified catalog ID.
  3. provider, apiBase, and the approved authentication mechanism should stay unchanged.
  4. Only the role intended for testing should be assigned. The same smoke tests should be repeated before the entry is introduced to other developers.

The configuration pattern should match the evaluation task:

Configuration pattern

Best for

Advantage

Trade-off

Single chat entry

Establishing a working baseline

Fewer configuration variables

Does not support a side-by-side model choice

Separate named entries

Comparing model behavior

Explicit selection and repeatable prompts

Each entry needs capability validation

Gateway failover

Handling provider failures under a defined routing policy

Routing remains behind the editor connection

A fallback response can differ from the original model's behavior

FastRouter supports automatic failover, but the editor connection alone does not establish the intended routing policy. The configured fallback behavior should be confirmed separately, with the output requirements that must remain valid across fallback models tested.

A catalog connection is not automatic catalog synchronization. This workflow configures selected IDs. If automatic discovery or configuration updates are needed, a supported mechanism should be verified before it becomes part of the deployment plan.

Expected result: developers can choose between the configured entries while using the same gateway connection. Each choice has a recorded capability check, rather than an assumption based on catalog membership.

Troubleshooting

The model entry does not appear

The active configuration file and YAML indentation should be checked. The entry should sit beneath models, not beside it, and the installed extension should accept the configuration format. Reloading should happen as required, with configuration errors inspected before the network is investigated.

Authentication is rejected

apiKey should be verified to supply the intended gateway credential with the required access. Accidental whitespace or an unresolved secret reference is worth checking. An exposed key should be replaced rather than reused during troubleshooting.

The request reaches an invalid path

apiBase should be compared with the documented API base character for character. A complete request endpoint should be removed if one was entered where an API base belongs. Proxy rewriting should be checked separately; a correct local setting does not prevent a proxy from altering the path.

The requested model is rejected

The model ID should be copied again from the current catalog, with access confirmed for the credential in use. The ID should not be shortened, nor a display label substituted. Only model should change, then the plain-text smoke test repeated.

Chat works, but streaming or tools fail

The failing capability should be tested separately. A successful chat response establishes basic request compatibility, not tool execution or streaming behavior. Continue's installed-version documentation and the selected model's supported capabilities should be checked before request settings change.

During the 2026 troubleshooting review, sanitized errors and configuration changes should be retained. Authorization headers, credentials, source code, and sensitive prompt content should be removed before diagnostics are shared.

Customizing the workflow

Expansion should wait until the baseline passes. Connection settings should stay stable while new roles or routing policies are introduced, so the cause of a regression can be identified.

  • Autocomplete should be added separately. A dedicated entry should be created only after compatibility with Continue's autocomplete workflow is confirmed. Chat quality is not an autocomplete validation result.
  • Editing behavior should be validated. How proposed changes apply to a disposable code sample should be tested before the integration is used on important repository changes.
  • Governance requirements should be reviewed. Permitted models, credential ownership, and acceptable handling of repository context should be defined. A working connection does not establish those policies.
  • Failover should be tested deliberately. Fallback output should be confirmed to still satisfy the application's format and capability requirements. A completed request is not enough if its output breaks the workflow.

3 acceptance checks are worth running before the configuration is distributed: successful authentication, usable code-context responses, and confirmed behavior for every assigned role. These checks are a rollout recommendation, not a claim about gateway performance.

For a 2026 team rollout, non-secret configuration should be distributed through the approved process, with credentials provisioned separately. A named owner for model changes keeps a catalog update from becoming an undocumented editor change.

FAQ

How is Continue.dev connected to FastRouter?

A Continue model entry is configured with the OpenAI provider, the documented gateway API base, an authorized API key, and an exact catalog model ID. The chat role should come first, with a plain-text request validated before advanced workflows are added.

Is a separate provider key needed for each model?

This workflow authenticates Continue to the gateway with a gateway credential, rather than configuring separate direct-provider connections. Any BYOK requirements must be handled according to the gateway's documented setup.

Does connecting the gateway import the whole model catalog?

This setup adds the model IDs explicitly configured; it does not implement automatic catalog synchronization. Separate entries should be added and validated for the models the team wants to select.

Can the same connection be used for autocomplete?

The gateway connection should be reused for autocomplete only after the selected model and Continue adapter are validated for it. A working chat entry does not prove autocomplete compatibility.

Why does Continue reject a model ID?

The model field should contain the exact current API identifier, with the credential confirmed to have access to it. A display name or shortened identifier is not a reliable substitute.

Can automatic failover change the response?

Yes, a fallback model can return different output from the originally requested model. The required format, capabilities, and editing behavior should be validated across the configured fallback policy.

How should this integration be validated in 2026?

A plain-text request and a small code-context request should run, with every additional role tested separately. The extension version, model ID, sanitized errors, and observed outcomes should be recorded without exposing credentials.

One last thing

A successful response is not the same as a successful coding workflow. The gateway can return valid text while the editor still lacks the behavior required to apply an edit or execute a tool. The first working chat entry should serve as the baseline, with each added capability validated independently.

Related Articles

Does an LLM gateway support virtual model aliases?
Does an LLM gateway support virtual model aliases?
Integration & Architecture

Does an LLM gateway support virtual model aliases?

LLM gateway virtual model aliases keep application names stable as model targets change. Learn how aliases differ from routing and what to validate.

F
FastRouter Team
10 Min Readâ—†November, 20 2026