My Chat Agent (2026 Edition)

Advanced AI Chat Assistant for VS Code with Cross-Provider Resilience

My Chat Agent seamlessly integrates powerful AI models (Google Gemini and OpenRouter) into your VS Code workflow. With a robust cross-provider retry logic, smart context management, and deep Hebrew support, it ensures an uninterrupted and productive development experience.

Features
How It Works
Installation & Setup
Usage
Configuration
Troubleshooting
Roadmap & Changes
Contributing
License
עברית

Features

Smart Diagnostics (New!)
Right-click on any code error in the Problems panel or terminal output to analyze and fix it instantly. The "Code Canvas" displays a Before/After diff with a single-click "Apply" button, allowing you to review and accept changes with confidence.
Centralized Prompt Engine
Utilizes structured XML tagging for precise prompt construction, significantly reducing AI hallucinations by clearly separating system instructions from user input and context.
Speculative Preloading
Proactively loads relevant project context and conversation history to minimize latency and improve response times, making interactions feel faster and more fluid.
Cross-Provider Strategy
Automatically cycles between Google Gemini and OpenRouter models. If one provider fails or hits a rate limit, the other takes over seamlessly, ensuring continuous operation.
Dual Master Keys
Simplified setup using separate API keys for Google and OpenRouter (supporting both free and paid tiers) via the VS Code Command Palette.
Smart Context Management
Automatically summarizes long conversations using the active model to maintain relevance while efficiently conserving API tokens and staying within context window limits.
Native Hebrew Support
Full Right-to-Left (RTL) optimization and automatic language detection (Hebrew/English) for a natural user experience.
Persistent Sessions
All chats are stored locally within VS Code's global storage, complete with AI-generated smart titles for easy session management and retrieval.

How It Works

My Chat Agent runs as a dedicated sidebar webview within VS Code. When you send a message, the extension orchestrates a sophisticated process:

Provider Determination: It first determines the target AI provider based on your preferredModel setting:
- Simple names (e.g., gemini-2.5-flash) are routed to Google Gemini.
- Names with a slash (e.g., anthropic/claude-3-opus) are routed to OpenRouter.
Contextual Indexing (3-Tier Indexing): Before sending your message, the extension performs a rapid 3-Tier Indexing of your project. This involves scanning up to 32 relevant project files (based on file names, content, and recent activity) to build a highly accurate and focused context for the AI. This ensures the AI has the most pertinent information about your codebase.
Prompt Construction (Centralized Prompt Engine): The system then employs its Centralized Prompt Engine. This engine uses structured XML tagging (e.g., <context>, <user_query>, <chat_history>) to meticulously construct the prompt. This structured approach ensures precise communication with the AI models, minimizing ambiguity and preventing "hallucinations."
API Call: It attempts to call the selected AI model via its respective API.
Resilience (Exponential Backoff & Fallback): If the API call fails (due to network errors, rate limits like HTTP 429, or other issues), the extension automatically retries with Exponential Backoff logic, gradually increasing the wait time between retries. If the primary model continues to fail, it will automatically attempt the fallbackModel (if configured) or switch to the alternative provider to ensure a response.
Conversation Summarization: For longer conversations, the system intelligently triggers a summarization step using the current model. This compresses the chat history, keeping the context window manageable and reducing token usage without losing critical information.
Error Fixing (Code Canvas): For error analysis and fixing, the extension captures the specific error context directly from the Problems panel or terminal output. This context is sent to the AI, and the proposed fix is rendered as an interactive diff view in the "Code Canvas," allowing you to review and apply changes.
Data Persistence: All chat data (history, session titles) is securely persisted in VS Code's global storage. API keys are encrypted and stored in VS Code's SecretStorage, never leaving your local machine.

The extension communicates directly with Google AI Studio and OpenRouter APIs; no intermediate servers are used, ensuring your data privacy.

Installation & Setup

Prerequisites

VS Code 1.80 or higher.
An active internet connection.
API keys:
- Google AI Studio (for Gemini models): Obtain your key from Google AI Studio.
- OpenRouter (for various models): Obtain your key from OpenRouter. Note that you may need separate keys for free and paid tiers, depending on the models you wish to use.

Steps

Install the extension
- From the VS Code Marketplace: search for "My Chat Agent" and click "Install."
- Alternatively, download the .vsix file from the GitHub releases and install it via the VS Code Command Palette (Ctrl+Shift+P or Cmd+Shift+P) by running Extensions: Install from VSIX....
Configure API Keys
Open the VS Code Command Palette (Ctrl+Shift+P or Cmd+Shift+P) and run the following commands, entering your respective API keys when prompted:
- My Chat Agent: Set Google API Key (או בעברית: My Chat Agent: הגדר מפתח Google) → Enter your Google API key.
- My Chat Agent: Set OpenRouter Free Models API Key (או בעברית: My Chat Agent: הגדר מפתח OpenRouter (Free Models)) → Enter your OpenRouter key for free models (if applicable).
- My Chat Agent: Set OpenRouter Paid Models API Key (או בעברית: My Chat Agent: הגדר מפתח OpenRouter (Paid Models)) → Enter your OpenRouter key for paid models (if applicable).
  Note: You only need to set the keys for the providers/tiers you intend to use.
Set Preferred Model
Open VS Code Settings (Ctrl+, or Cmd+,), search for myChatAgent, and configure the following:
- myChatAgent.preferredModel: Specify your primary AI model. Use a simple name for Google models (e.g., gemini-2.5-flash) or provider/model-id for OpenRouter models (e.g., anthropic/claude-3-opus).
- myChatAgent.fallbackModel (optional): Set a secondary model that the extension will try if the preferredModel fails. Use the same format as above. Leave this setting empty to disable the fallback mechanism.
- myChatAgent.forceLanguage: Control the chat interface language: auto (default, detects language), he (force Hebrew), or en (force English).
Reload VS Code (if the "Chat Agent" sidebar icon doesn't appear automatically after installation and configuration).

Usage

Open the Chat
Click the "Chat Agent" icon in the Activity Bar (the left sidebar in VS Code) to open the chat webview.
Chatting
Type your message in the input box at the bottom of the chat panel and press Enter. The AI response will stream in real-time.
Fix Errors
Right-click on any error message displayed in the Problems panel or within the terminal output. From the context menu, select My Chat Agent: Fix Error from Terminal/Problems. A "Code Canvas" will appear, showing the proposed fix as a diff. Review the changes and click the Apply button to insert them directly into your file.
Manage Sessions
Use the session dropdown menu at the top of the chat panel to switch between different conversations. Chat titles are automatically generated by the AI based on the first message of each session.
Clear Keys
If you need to reconfigure your API keys or remove them, open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P) and run My Chat Agent: Clear All API Keys.
Open Settings
To quickly access the extension's configuration, run My Chat Agent: Open Settings from the Command Palette.

Configuration

The following settings are available under the myChatAgent extension identifier in VS Code Settings:

Setting	Default	Description
`myChatAgent.preferredModel`	`gemini-2.5-flash`	The primary AI model to use. For Google models, use the simple name (e.g., `gemini-2.0-flash`). For OpenRouter models, use the format `provider/model-id` (e.g., `anthropic/claude-3-opus`), as listed on OpenRouter's model page.
`myChatAgent.fallbackModel`	`""`	An optional secondary model to use if the `preferredModel` fails. Uses the same format as `preferredModel`. Leave empty to disable this fallback mechanism.
`myChatAgent.forceLanguage`	`auto`	Forces the language of the chat interface: `auto` (automatically detects language), `he` (force Hebrew), or `en` (force English).

Note: Additional internal settings may be introduced in future updates to further customize behavior.

Troubleshooting

Issue	Solution
"Invalid API key" error	Double-check that you entered the correct API key(s) via the Command Palette. API keys are stored securely in VS Code's SecretStorage. If issues persist, you can clear all stored keys using `My Chat Agent: Clear All API Keys` and re-enter them.
"Model not found" error	Verify the model name format in your settings. For Google models, use the exact simple name (e.g., `gemini-2.5-flash`). For OpenRouter models, ensure you use the `provider/model-id` format as specified on OpenRouter's model page.
Network errors / timeouts	Ensure your internet connection is stable. The extension connects directly to the Google and OpenRouter APIs without intermediaries.
Error fixing not appearing	The "Fix Error" command operates on selected (highlighted) error text in the Problems panel or terminal output. Make sure an error is clearly selected before right-clicking and invoking the command.
RTL layout issues (e.g., Hebrew text alignment)	If you experience issues with Right-to-Left text rendering, set `myChatAgent.forceLanguage` to `he` in your VS Code settings to explicitly enforce Hebrew RTL layout.
Extension not activating or sidebar not appearing	Ensure your VS Code version is 1.80 or higher. Try reloading the VS Code window by opening the Command Palette (`Ctrl+Shift+P` or `Cmd+Shift+P`) and running `Developer: Reload Window`.

Roadmap & Changes

v1.0.1 (2026 Edition)

✨ Smart Diagnostics: Introduced the interactive "Code Canvas" for instant error analysis and one-click application of proposed fixes.
🧠 Core Architecture: Implemented a robust Centralized Prompt Engine with XML tagging for enhanced accuracy and a Speculative Preloading mechanism for improved responsiveness.
⚡ Performance Boost: Achieved significant optimization by eliminating a 9MB TypeScript dependency, resulting in a rapid compilation time of approximately 1.3 seconds.
🔄 Cross-Provider Retry: Enhanced fallback logic to seamlessly switch between Google Gemini and OpenRouter providers, ensuring higher availability.
🛡️ Resilience: Integrated advanced Exponential Backoff logic for API calls, significantly improving stability and handling of rate limits.
🎨 RTL Improvements: Further refined Hebrew text rendering and alignment for a more polished user experience.
⚙️ Configuration: Added the fallbackModel setting, providing users with more robust resilience options.
🗣️ Context Summarization: Implemented automatic conversation summarization to efficiently manage token usage and maintain relevant context in long chats.

v1.0.0

Initial release featuring Dual Master Keys, Native Hebrew Support, Persistent Sessions, and foundational cross-provider support.

Future Plans (subject to change):

Support for additional AI providers (e.g., Anthropic, OpenAI direct integration).
Voice input/output capabilities for hands-free interaction.
Integrated unit test generation based on code context.
Collaborative session sharing for team development.

Contributing

Contributions are welcome! If you encounter issues, have feature suggestions, or wish to contribute code, please open an issue or submit a pull request on the GitHub repository.

License

MIT © Adi Alamo

עברית