DEV Community: Arpan Dhara

Integrating AgentRouter with Tauric Research TradingAgents

Arpan Dhara — Sat, 08 Aug 2026 17:06:56 +0000

If you're using Tauric Research's TradingAgents framework and want to add AgentRouter as a fully supported LLM provider, this guide will walk you through the complete integration.

The process is organized file-by-file, so you can open each file and make all of the required changes before moving to the next one.

TradingAgents Repository:
[https://github.com/TauricResearch/TradingAgents.git]

What We'll Do

In this tutorial, we'll:

Register the AgentRouter API endpoint
Configure the AgentRouter WAF-bypass headers
Add AgentRouter's model catalog
Configure the AgentRouter API key environment variable
Bypass strict model-name validation
Add AgentRouter to the TradingAgents CLI
Configure the .env file
Reinstall and restart TradingAgents

Let's get started.

Step 1 — Update `openai_client.py`

Open:

tradingagents/llm_clients/openai_client.py

This file requires two changes:

Register the AgentRouter API endpoint
Configure the headers required by AgentRouter

The integration guide specifically places both changes in this file.

1A — Register the AgentRouter API Endpoint

Locate the:

OPENAI_COMPATIBLE_PROVIDERS

dictionary.

Add AgentRouter alongside the existing OpenAI-compatible providers:

"openrouter": ProviderSpec(
    base_url="https://openrouter.ai/api/v1"
),
"agentrouter": ProviderSpec(
    base_url="https://agentrouter.org/v1"
),

The important part here is the AgentRouter base URL:

https://agentrouter.org/v1

This allows TradingAgents to communicate with AgentRouter through its OpenAI-compatible API interface.

1B — Configure AgentRouter WAF-Bypass Headers

Still in:

tradingagents/llm_clients/openai_client.py

Locate the get_llm(self) method inside the OpenAIClient class.

Find the section that forwards user-provided keyword arguments:

# Forward user-provided kwargs
for key in _PASSTHROUGH_KWARGS:
    if key not in self.kwargs:
        continue
    if key == "reasoning_effort" and not _supports_reasoning_effort(self.model):
        continue
    llm_kwargs[key] = self.kwargs[key]

Immediately after this section, add the AgentRouter-specific headers:

# Forward user-provided kwargs
for key in _PASSTHROUGH_KWARGS:
    if key not in self.kwargs:
        continue
    if key == "reasoning_effort" and not _supports_reasoning_effort(self.model):
        continue
    llm_kwargs[key] = self.kwargs[key]

# --- NEW CODE START: Add spoofed headers for AgentRouter ---
if self.provider == "agentrouter":
    llm_kwargs["default_headers"] = {
        "Originator": "codex_cli_rs",
        "User-Agent": "codex_cli_rs/0.114.0 (Windows 10.0.26100; x86_64)",
        "Version": "0.114.0",
    }

# --- NEW CODE END ---

# The subclass (provider quirks) comes from the registry spec.
return chat_cls(**llm_kwargs)

These headers are part of the AgentRouter integration described in the guide.

Important: Make sure this code is placed inside the get_llm(self) method and before the final return chat_cls(**llm_kwargs).

Step 2 — Update `model_catalog.py`

Now open:

tradingagents/llm_clients/model_catalog.py

This file controls the models that can be selected for each provider.

2A — Define AgentRouter Models

Near the top of the file, around the existing model definitions, add:

_AGENTROUTER_MODELS: dict[str, list[ModelOption]] = {
    "quick": [
        ("GPT-4o Mini", "openai/gpt-4o-mini"),
        ("Claude 3.5 Haiku", "anthropic/claude-3-haiku"),
        ("DeepSeek V3", "deepseek/deepseek-chat"),
        ("Custom model ID", "custom"),
    ],
    "deep": [
        ("GPT-4o", "openai/gpt-4o"),
        ("Claude 3.5 Sonnet", "anthropic/claude-3-5-sonnet"),
        ("DeepSeek R1", "deepseek/deepseek-reasoner"),
        ("Custom model ID", "custom"),
    ],
}

The quick category contains lighter model choices, while deep contains the deeper/reasoning-oriented choices listed in the integration guide.

2B — Register the AgentRouter Model Catalog

Scroll down to:

MODEL_OPTIONS

Add the AgentRouter mapping:

"bedrock": _CUSTOM_ONLY,
"agentrouter": _AGENTROUTER_MODELS,

This connects the agentrouter provider with the model catalog you just created.

Step 3 — Update `api_key_env.py`

Open:

tradingagents/llm_clients/api_key_env.py

Locate:

PROVIDER_API_KEY_ENV

Add the AgentRouter environment variable:

"openrouter": "OPENROUTER_API_KEY",
"agentrouter": "AGENTROUTER_API_KEY",

This tells TradingAgents to retrieve the AgentRouter API key from:

AGENTROUTER_API_KEY

The integration guide specifies this exact provider-to-environment-variable mapping.

Step 4 — Update `validators.py`

Open:

tradingagents/llm_clients/validators.py

TradingAgents normally performs strict validation of model names.

For AgentRouter, add the provider to:

_ANY_MODEL_PROVIDERS

The resulting tuple should include agentrouter:

_ANY_MODEL_PROVIDERS = (
    "ollama",
    "openrouter",
    "openai_compatible",
    "mistral",
    "kimi",
    "groq",
    "nvidia",
    "bedrock",
    "agentrouter",
)

This allows AgentRouter to work with model IDs without being restricted by the strict model-name validation.

Step 5 — Update `cli/utils.py`

Now open:

cli/utils.py

Locate:

_llm_provider_table()

This function contains the providers displayed in the interactive TradingAgents CLI.

Find the OpenRouter entry and add AgentRouter immediately after it:

("OpenRouter", "openrouter", "https://openrouter.ai/api/v1"),
("AgentRouter", "agentrouter", "https://agentrouter.org/v1"),

After this change, AgentRouter should appear as a selectable provider when you launch the TradingAgents CLI.

Step 6 — Configure the `.env` File

Now open the .env file in the root directory of your TradingAgents project.

Add your AgentRouter API key:

AGENTROUTER_API_KEY=your_actual_agentrouter_key_here

Replace:

your_actual_agentrouter_key_here

with your actual AgentRouter API key.

Keep Your API Key Private

Do not commit your .env file or API key to GitHub.

Make sure your .gitignore contains:

.env

Step 7 — Reinstall and Restart TradingAgents

Once you've completed all of the modifications, save your files.

Open your VS Code terminal and run:

pip install -e .

This reinstalls the package in editable mode so the modified Python definitions are refreshed.

Then launch TradingAgents:

TradingAgents

The integration guide specifically recommends restarting the CLI session after making the code changes so Python loads the modified code from disk.

Complete File Checklist

At this point, you should have modified the following files:

tradingagents/
├── llm_clients/
│   ├── openai_client.py
│   ├── model_catalog.py
│   ├── api_key_env.py
│   └── validators.py
│
└── cli/
    └── utils.py

.env

Here's a quick summary of what changes in each file:

openai_client.py
    ├── AgentRouter API endpoint
    └── AgentRouter WAF-bypass headers

model_catalog.py
    └── AgentRouter model definitions

api_key_env.py
    └── AGENTROUTER_API_KEY mapping

validators.py
    └── AgentRouter model validation bypass

cli/utils.py
    └── AgentRouter CLI provider entry

.env
    └── Your AgentRouter API key

Quick Verification Checklist

Before launching TradingAgents, verify that you have completed every step:

[ ] Added the AgentRouter API endpoint
[ ] Added the AgentRouter headers inside get_llm()
[ ] Added _AGENTROUTER_MODELS
[ ] Added "agentrouter" to MODEL_OPTIONS
[ ] Added AGENTROUTER_API_KEY to PROVIDER_API_KEY_ENV
[ ] Added "agentrouter" to _ANY_MODEL_PROVIDERS
[ ] Added AgentRouter to the CLI provider table
[ ] Added your AgentRouter API key to .env
[ ] Ran pip install -e .
[ ] Restarted the TradingAgents CLI

Conclusion

That's it!

AgentRouter is now registered as a provider in the TradingAgents framework, with:

OpenAI-compatible API support
AgentRouter-specific headers
Predefined model selections
Custom model support
Environment-based API key configuration
CLI provider selection

You can now launch TradingAgents and select AgentRouter from the interactive provider menu.

TradingAgents Repository:
[YOUR_TRADINGAGENTS_REPOSITORY_LINK]

If you're integrating another OpenAI-compatible provider into TradingAgents, the same general architecture can be useful: provider registration, model catalog configuration, API-key mapping, validation rules, and CLI registration.

Final Integration Flow

AgentRouter
     │
     ▼
API Endpoint Registration
     │
     ▼
OpenAIClient
     │
     ├── AgentRouter Headers
     │
     ▼
Model Catalog
     │
     ▼
API Key Environment Variable
     │
     ▼
Model Validation
     │
     ▼
TradingAgents CLI
     │
     ▼
AgentRouter LLM

Happy trading! 🚀

Integrating TokenRouter with Tauric Research TradingAgents

Arpan Dhara — Sat, 08 Aug 2026 17:02:48 +0000

If you're using Tauric Research's TradingAgents framework and want to integrate TokenRouter as an LLM provider, this guide walks through the complete process step by step.

The integration adds TokenRouter support to the TradingAgents interactive CLI and provides a predefined list of models that you can select directly from the interface.

TradingAgents Repository:
[https://github.com/TauricResearch/TradingAgents.git]

What We'll Do

In this tutorial, we'll:

Define TokenRouter models in the model catalog
Register the TokenRouter API endpoint
Configure the TokenRouter API key
Bypass strict model-name validation
Add TokenRouter to the interactive CLI
Configure the .env file
Reinstall and restart TradingAgents

Let's get started.

Step 1 — Define TokenRouter Models in the Model Catalog

First, open:

tradingagents/llm_clients/model_catalog.py

Near the top of the file, around the model definitions section, add a TokenRouter model dictionary.

_TOKENROUTER_MODELS: dict[str, list[ModelOption]] = {
    "quick": [
        ("GPT-4o Mini", "openai/gpt-4o-mini"),
        ("Claude 3.5 Haiku", "anthropic/claude-3-haiku"),
        ("DeepSeek V3", "deepseek/deepseek-chat"),
        ("Custom model ID", "custom"),
    ],
    "deep": [
        ("GPT-4o", "openai/gpt-4o"),
        ("Claude 3.5 Sonnet", "anthropic/claude-3-5-sonnet"),
        ("DeepSeek R1", "deepseek/deepseek-reasoner"),
        ("Custom model ID", "custom"),
    ],
}

The quick and deep categories provide predefined model choices.

You can also use the custom option when you want to specify your own model ID.

Next, locate MODEL_OPTIONS, around the section where providers are mapped.

Add tokenrouter after bedrock:

"bedrock": _CUSTOM_ONLY,
"tokenrouter": _TOKENROUTER_MODELS,

After this change, TradingAgents will know which models should be presented when TokenRouter is selected.

Step 2 — Register the TokenRouter API Endpoint

Now we need to tell TradingAgents where the TokenRouter API is located.

Open:

tradingagents/llm_clients/openai_client.py

Find:

OPENAI_COMPATIBLE_PROVIDERS

Add TokenRouter to the provider definitions:

"openrouter": ProviderSpec(
    base_url="https://openrouter.ai/api/v1"
),
"tokenrouter": ProviderSpec(
    base_url="https://api.tokenrouter.com/v1"
),

TokenRouter is registered here as an OpenAI-compatible provider.

Step 3 — Configure the TokenRouter API Key Environment Variable

Next, open:

tradingagents/llm_clients/api_key_env.py

Find:

PROVIDER_API_KEY_ENV

Add the TokenRouter environment variable:

"openrouter": "OPENROUTER_API_KEY",
"tokenrouter": "TOKENROUTER_API_KEY",

This tells TradingAgents which environment variable contains the TokenRouter API key.

Step 4 — Bypass Strict Model Name Validation

TradingAgents may normally validate model names against its predefined rules.

Because TokenRouter can provide different models through its API, we need to add it to the providers that allow arbitrary model names.

Open:

tradingagents/llm_clients/validators.py

Locate:

_ANY_MODEL_PROVIDERS

Then add tokenrouter:

_ANY_MODEL_PROVIDERS = (
    "ollama",
    "openrouter",
    "openai_compatible",
    "mistral",
    "kimi",
    "groq",
    "nvidia",
    "bedrock",
    "tokenrouter",
)

This allows TokenRouter model IDs to pass through the model validation layer.

Step 5 — Add TokenRouter to the Interactive CLI

Now we'll make TokenRouter visible in the TradingAgents interactive CLI.

Open:

cli/utils.py

Locate:

_llm_provider_table()

Find the OpenRouter entry and add TokenRouter immediately after it:

("OpenRouter", "openrouter", "https://openrouter.ai/api/v1"),
("TokenRouter", "tokenrouter", "https://api.tokenrouter.com/v1"),

After this change, TokenRouter should appear as a selectable provider when you launch the TradingAgents CLI.

Step 6 — Add Your TokenRouter API Key

Now we need to provide your TokenRouter API key.

Open the .env file in the root directory of the TradingAgents project.

Add:

TOKENROUTER_API_KEY=your_actual_tokenrouter_key_here

Replace:

your_actual_tokenrouter_key_here

with your actual TokenRouter API key.

Important: Never commit your .env file or API key to GitHub.

Make sure .env is included in your .gitignore.

Step 7 — Reinstall and Restart TradingAgents

After making all of the changes, save your files.

Open the VS Code terminal and reinstall the project in editable mode:

pip install -e .

Then launch TradingAgents:

TradingAgents

Restarting the application is important because Python needs to load the modified definitions from disk.

Final Project Changes

After completing the integration, you should have modified the following files:

tradingagents/
├── llm_clients/
│   ├── model_catalog.py
│   ├── openai_client.py
│   ├── api_key_env.py
│   └── validators.py
│
└── cli/
    └── utils.py

.env

The main additions are:

TokenRouter model definitions
        ↓
TokenRouter API endpoint
        ↓
TOKENROUTER_API_KEY environment variable
        ↓
Model validation bypass
        ↓
TokenRouter CLI provider
        ↓
TradingAgents

That's It!

TokenRouter is now integrated into the TradingAgents framework as an LLM provider.

You should now be able to select TokenRouter from the interactive CLI and use the predefined models or provide a custom model ID.

If you're working with the Tauric Research TradingAgents project, you can find the repository here:

Repository:
[YOUR_TRADINGAGENTS_REPOSITORY_LINK]

Quick Checklist

Before running TradingAgents, make sure you've completed everything:

[ ] Added _TOKENROUTER_MODELS
[ ] Added "tokenrouter" to MODEL_OPTIONS
[ ] Added the TokenRouter API endpoint
[ ] Added TOKENROUTER_API_KEY
[ ] Added TokenRouter to _ANY_MODEL_PROVIDERS
[ ] Added TokenRouter to the CLI provider table
[ ] Added your API key to .env
[ ] Ran pip install -e .
[ ] Restarted TradingAgents

If all of the above are complete, you should be ready to use TokenRouter with TradingAgents.

This integration guide is based on the TokenRouter integration procedure for the TradingAgents framework.

DEV Community: Arpan Dhara

Integrating AgentRouter with Tauric Research TradingAgents

What We'll Do

Step 1 — Update openai_client.py

1A — Register the AgentRouter API Endpoint

1B — Configure AgentRouter WAF-Bypass Headers

Step 2 — Update model_catalog.py

2A — Define AgentRouter Models

2B — Register the AgentRouter Model Catalog

Step 3 — Update api_key_env.py

Step 4 — Update validators.py

Step 5 — Update cli/utils.py

Step 6 — Configure the .env File

Keep Your API Key Private

Step 7 — Reinstall and Restart TradingAgents

Complete File Checklist

Quick Verification Checklist

Conclusion

Final Integration Flow

Integrating TokenRouter with Tauric Research TradingAgents

What We'll Do

Step 1 — Define TokenRouter Models in the Model Catalog

Step 2 — Register the TokenRouter API Endpoint

Step 3 — Configure the TokenRouter API Key Environment Variable

Step 4 — Bypass Strict Model Name Validation

Step 5 — Add TokenRouter to the Interactive CLI

Step 6 — Add Your TokenRouter API Key

Step 7 — Reinstall and Restart TradingAgents

Final Project Changes

That's It!

Quick Checklist

Step 1 — Update `openai_client.py`

Step 2 — Update `model_catalog.py`

Step 3 — Update `api_key_env.py`

Step 4 — Update `validators.py`

Step 5 — Update `cli/utils.py`

Step 6 — Configure the `.env` File