OpenCode to VSCode Bridge

Author: Vlado Vrbanec — vlado.vrbanec@mvv.hr

⚠️ Requires OpenCode > 2.0 — this build works only with OpenCode versions newer than 2.0. If you are running an older OpenCode, uninstall this version and install 0.2.2 instead.

FAST-START Do not read any further.

• Install the extension into VS Code.
• Restart your favorite OpenCode development environment and create a project in the same folder as VSCode.
• Ask any agent "Create an empty JS file "TEST.js" with functional function multiply , and open it in the VSC editor".
• Then, in the editor, below created function write "//LAKI: now here create the oposite function" and press ALT+O .
• If this sounds good, install the extension in VSCode, and read the rest of the text later, if you need to.

ℹ️ The concept is really powerful, however it is also complex. Discover the functionality layer by layer according to your own needs and expertise. Ask your agent for help : "Which tools do you have from VSCode Bridge toolset?"

ℹ️ Please be aware that all tools described in this file are used by an agent, and none is intended to be used by the user.

ℹ️ An intelligent agent does not need any of what is written here explained — it receives all information through the MCP bridge, and may occasionally just need to be reminded which tools you want it to use. For example, select some code in the editor and instruct in OpenCode "Use VSC select tool and check if selected code is correct". Or "Use VSC select tool and translate selected code to Italian".

Purpose: Agent awareness of the user's visual working environment. The AI agent can see which tabs are open, cursor position, selection range, dirty (unsaved) state per file, and manipulate the editor directly. This lets the agent reason about what the user sees and work contextually within their editor.

Works in terminal or GUI client applications. Also works with any VSCode sidebar extension, or HTTP connected application. Agent can call 27 base MCP tools + 23 debug + 13 LSP + 3 Decorate + 5 Sessions + 4 WebView tools (all except base loaded on demand, 75 unique) + slash commands (/vsc core + per-pack /_tools — only when the pack is registered).

Works with up to 5 VSCode sessions (windows) simultaneously.

Bridge is pure Node.js — likely works on macOS and Linux, but only tested on Windows.

Terminal or TUI Electron app ?

• OpenCode can run as a terminal application (CLI) or as a GUI application built with Electron/Tauri.

• We recommend using the GUI for better user experience.

• GUI can run multiple tabs, multiple sessions, and multiple workspaces.

• Reconnections to VSCode session with the same workspace is automatically handled.

• My apsolute favorite : https://openchamber.dev

• Or original OpenCode desktop : https://opencode.ai/download/stable/windows-x64-nsis

Base MCP tools (always loaded — 27)

health, info, version, selection, source, open, goto_line, command, commands, tool_topic, edit_replace, edit_range, insert_at_line, edit_selection, undo, redo, clear_marks, edit_file, edit_create, files, workspace_files, symbols, search, output_read, output_list, last_reasoning, speak

Debug MCP tools (loaded on demand via tool_topic("debug") — 23)

debug_configurations, debug_prerequisites, debug_build, debug_start, debug_stop, debug_pause, debug_session, debug_overview, debug_thread_list, debug_state, debug_callstack, debug_where, debug_breakpoints, debug_exceptions, debug_continue, debug_step_over, debug_step_into, debug_step_out, debug_variables, debug_evaluate, debug_console_write, debug_set_variable, debug_console

ℹ️ Debug tools are not loaded into the agent's context by default. The agent calls tool_topic("debug") to register them on demand, saving context tokens when debugging is not needed.

LSP MCP tools (loaded on demand via tool_topic("lsp") — 13)

lsp_diagnostics, lsp_definition, lsp_type_definition, lsp_implementation, lsp_references, lsp_hover, lsp_rename, lsp_document_symbols, lsp_workspace_symbols, lsp_completion, lsp_code_actions, lsp_apply_code_action, lsp_call_hierarchy

ℹ️ LSP tools provide semantic code analysis via the Language Server Protocol — definitions, references, diagnostics, type information. The agent calls tool_topic("lsp") to make them available. These are NOT loaded by default to save context tokens.

Decorate MCP tools (loaded on demand via tool_topic("decorate") — 3)

decorate_range, decorate_gutter, decorate_clear

Sessions MCP tools (loaded on demand via tool_topic("sessions") — 5)

session_list, session_get, session_messages, session_prompt, session_delete

ℹ️ Decorate tools let the agent paint visual markers in the editor WITHOUT modifying file content — color code regions, add colored gutter dots, and clear decorations. Unlike edit highlights, decorates do NOT auto-dismiss. The agent calls tool_topic("decorate") to make them available. Creation requires the target file to be visible — if the user switches tabs while decorating, the call fails with File is not open in any editor tab (edits via edit_range/insert_at_line are safe cross-tab).

ℹ️ Tools are used by the AI agent, not the user. For file reading and editing, the agent can use OpenCode's built-in tools or MCP tools.

ℹ️ Agent automatically discovers tool endpoints and parameters via MCP protocol.

Debugging

🔧 The bridge provides full active debugger control via VSCode's Debug Adapter Protocol (DAP). The agent can start and stop debug sessions, set breakpoints, step through code, inspect variables at runtime, evaluate expressions in the current execution context, and read program output — all through 25 dedicated debug tools. Instead of passively reasoning about bugs from source code alone, the agent can now observe the program's actual runtime state: variable values, call stacks, thread status, and live output. This transforms debugging from static analysis into an interactive diagnostic loop where the agent correlates source code with real execution behavior, dramatically improving its ability to identify root causes.

Debug workflow

1. debug_prerequisites — check environment readiness (SDK, launch.json, project files)
2. debug_build — build the project (uses tasks.json or falls back to dotnet build)
3. debug_start — start a debug session from launch.json config
4. Poll debug_state (with compact:true) until stopped:true
5. debug_where — see file, line, and source around the stop location
6. debug_variables / debug_evaluate — inspect variables and expressions
7. debug_continue / debug_step_over — advance execution, then poll again

ℹ️ After debug_continue or step commands, the agent polls debug_state until stopped:true — execution is asynchronous.

ℹ️ When debugging a GUI/EXE application, the agent cannot click buttons in the app window. It tells the user explicitly what to do, then polls for breakpoints or output.

ℹ️ To test just stop on debugger point and type to the agent "Play litle with debugger" or "Please check error opened in debugger".

Language Server Protocol (LSP)

The bridge exposes VSCode's Language Server infrastructure to the agent — semantic code analysis without running the program. The agent calls tool_topic("lsp") once to load the LSP tools.

ℹ️ LSP requires a VSCode extension for the language (TypeScript, C#, Python, etc.) — the bridge uses whatever Language Server is already active in VSCode.

ℹ️ lsp_diagnostics returns live errors from the Language Server — different from build/compile errors. Use it before debugging to catch type and syntax issues early.

Visual Decorations

The bridge lets the agent paint visual markers in the editor without changing file content. Unlike edit highlights (which auto-dismiss and are tied to edits), these decorations persist until explicitly cleared.

Available colors: red, green, blue, yellow, purple, orange, cyan, pink, gray — or any CSS rgba/hsl/hex string.

ℹ️ The agent calls tool_topic("decorate") once to load these tools. Decorations persist once created and do NOT auto-dismiss (they survive tab switches), but creation requires the file to be visible — keep the target file active while decorating or call open(file) first.

WebView Panels

The bridge lets the agent open and control webview panels — HTML pages rendered in their own VSCode tab. This is how the agent presents results that are richer than plain chat text: rendered markdown, data tables, dashboards, charts, or any custom HTML UI.

Content formats

webview_show renders three kinds of content, so the agent does not have to build HTML by hand:

Example — show build results as a table:

webview_show(name="build", json=[{file:"a.ts", errors:0}, {file:"b.ts", errors:2}], tableColumns=[{key:"file",label:"File"},{key:"errors",label:"Errors"}])

ℹ️ The agent calls tool_topic("webview") once to load these tools. Panels persist until closed explicitly (webview_clear) or VSCode shuts down.

ℹ️ To test, instruct your agent "Please write a nice message in the VSC WebView for my darling Suzana".

Slash commands (from version 0.0.3)

User-facing shortcuts. Type /vsc in the OpenCode chat to run an editor-aware task. No configuration needed.

| /vsc | Signal the agent that the rest of the conversation relates to working with the VSCode editor |

ℹ️ Additionally installed extensions with extra functionality may add their own slash commands.

Quick Install

ℹ️ If not installed from VSCode side panel:

Install from marketplace.

OpenCode to VSCode Bridge — VS Code Marketplace

OpenCode plugin setup (required)

The OpenCode plugin is automatically installed when you start the VSCode extension.

⚡ If OPENCODE is installed after extension, please reinstall VSCode extension.

Usage

When component is installed, start or restart opencode. The plugin automatically connects to the VSCode bridge when you open a workspace folder.

Ask the agent a few questions:

ℹ️ Doesn't need to be exact, agent will understand the context. ⚡ If agent is not aware of available tools, execute /vsc command to set editor context.

ℹ️ Instructions to the agent can be in any language, not just English; however, the agent will pick up context at the beginning of the session in English faster.

Agent will probably 'think' in English but will understand your language, and answer in your language.

⚡ If the agent doesn't immediately respond to editor context, start with "vsc" — it's a trigger word that anchors the conversation to the editor.

• Which file is opened in editor?
• What is the current cursor position?
• What is the current line number?
• What is the current column number?
• What is the selected text?
• Check current editor selection for errors.
• Please debug file opened in editor.
• ... and other questions

When the AI agent knows the context, we can ask without specifying the file name:

• Check selected file for errors.
• Insert "This text" at cursor position.
• Why my code fail on current editor line ?
• Please create comment for function MyExampleFunction.
• Please check selected lines for errors.
• Translate selected text to Italian

And other instructions in natural language.

Agent will automatically try to obey instructions. With time you will learn which instructions are more clear to the agent.

⚡If VSCode extension is not active, or used folder is not the same, agent will respond with an predefined error message.

Status Bar

The extension adds a status bar indicator at the bottom-right of VSCode: Mouse over icon will display info about last Opencode connection:

Click on the status bar item to open the Actions Menu:

Inline Coding Assistant

Press a key combination directly in the editor to generate or edit code right where the cursor is. The bridge supports three modes, chosen per keypress — no settings to flip when you want a different level of power:

Which mode should you press?

• You just want the code → Alt+U. It never edits anything by itself.
• One self-contained job ("fix this function", "add validation") → Alt+I. Clean slate every time, nothing accumulates.
• Iterating on something bigger → Alt+O. The conversation continues, so follow-ups work without repeating the context.

Alt+I and Alt+O never share a session: Alt+I always starts fresh, Alt+O always continues its own per-file session.

Context per mode

Native and smart cost roughly the same per press — native is cheaper in behaviour, not in tokens: no tools, no history, no project instructions, which is also why it answers fastest. Supersmart grows as its session grows, and its project rules (AGENTS.md) are always in play.

While the model is working, the source lines under the cursor/selection are highlighted with a thinking decoration (animated green box) instead of any text being inserted into the document.

The result arrives as gray/italic ghost text with a hover box in native mode (✓ Accept / ✗ Reject, Tab = Accept, Esc = Reject). If the agent produced reasoning, a 💭 View agent reasoning link appears in the hover — click it to open a side panel with the full reasoning trace.

ℹ️ Smart and supersmart sessions are shared with your OpenCode applications (terminal and GUI client) — you can see them in the app's session list, and they consume the same resources. Native uses a throwaway session that is deleted immediately, so it never shows up anywhere.

The three commands are also available from the Command Palette: OpenCode Bridge: Inline Native (Alt+U), OpenCode Bridge: Inline Smart (Alt+I), OpenCode Bridge: Inline Supersmart (Alt+O). Keybindings can be customized in Keyboard Shortcuts (Ctrl+K Ctrl+S).

Native mode notes

• Native mode goes through OpenCode, so it uses your OpenCode model and credentials. opencodeBridge.inlineProviderUrl / inlineApiKey are only a fallback for setups where the bridge cannot reach an OpenCode server at all.
• For debugging the exact request/response, set opencodeBridge.logMode to developer — a full dump (endpoint, model, masked key, status, latency, raw body) is written to a debug log file.
• INLINENATIVE.md — optional per-project file in your workspace root. It is the only project context native mode (Alt+U) gets: the project's AGENTS.md and other instruction files are deliberately left out to keep the call small and fast, so this file is where you tell native mode about the project — e.g. This project is a JavaScript application. Conclude source type from source or file extension. Smart and supersmart already load the project instructions on their own.

Configuration

Settings are available in VSCode Settings UI (Ctrl+, → search "OpenCode Bridge") or settings.json.

To reset all settings to defaults: open the Actions Menu (click the status bar item) and choose Reset Settings to Defaults, or run command OpenCode Bridge: Reset Settings to Defaults from the Command Palette.

Changes take effect on the next OpenCode session.

Notes

• Each OpenCode instance automatically pairs with VSCode running in the same workspace.