RooCode

Roo Code implements a provider-agnostic API handler architecture that abstracts OpenAI, Anthropic, Google, and local model APIs behind a unified interface. The system handles model discovery caching, token usage calculation per provider, and streaming response processing with real-time token counting. The ClineProvider core orchestrator routes requests to the appropriate provider based on user configuration, manages authentication profiles, and normalizes responses across different API schemas.

Roo Code implements a two-tier tool system: native tools (file operations, terminal commands, code execution) registered in a schema-based function registry, plus Model Context Protocol (MCP) tools that extend capabilities through external servers. Tools are executed only after user approval (configurable per tool or auto-approve for trusted operations), with results formatted and returned to the AI model for further reasoning. The tool architecture includes safety guardrails, result formatting, and error handling with retry logic.

Roo Code provides a settings UI for configuring AI providers, models, auto-approval rules, context management, and experimental features. Settings are organized into tabs (providers, models, auto-approve, context, terminal, checkpoints, notifications, experimental). Provider configuration supports multiple profiles (e.g., 'development', 'production') with different API keys and models. Settings are persisted to VS Code's configuration storage and can be synced across devices if VS Code settings sync is enabled.

Roo Code integrates with a cloud platform for task sharing, synchronization, and authentication. Tasks can be shared with team members via cloud links, and task execution can be synchronized across devices. The system supports MDM (Mobile Device Management) integration for enterprise authentication. Cloud service architecture includes task persistence, user authentication, and team collaboration features. Tasks are uploaded to the cloud and can be accessed from any device with the same account.

Roo Code implements comprehensive internationalization with localized documentation (README, guides) and UI strings in 10+ languages (Chinese, Japanese, Korean, Spanish, French, German, Portuguese, Turkish, Vietnamese, Polish, Catalan). The i18n system uses a translation file structure and integrates with the webview UI to display localized strings. Documentation is translated and maintained per language, and the UI automatically detects the VS Code language setting to display the appropriate locale.

Roo Code includes a CLI application that enables headless task execution without the VS Code UI. The CLI supports task execution modes, configuration via command-line arguments or config files, and output formatting (JSON, text). The CLI can be integrated into CI/CD pipelines, scheduled jobs, or automation scripts. Task execution via CLI follows the same task lifecycle and tool execution as the webview, but without user approval gates (configurable via auto-approve settings).

Roo Code includes an evaluation framework for benchmarking agent performance on coding tasks. The framework supports running predefined evaluation suites, measuring success rates, execution time, and token usage. Evaluations can be configured to test different models, providers, and configurations. Results are collected and can be analyzed to identify performance regressions or improvements. The evaluation system integrates with the task execution engine and captures detailed metrics.

Roo Code manages autonomous coding tasks through a task stack system where each task can spawn subtasks, with full lifecycle tracking (creation, execution, completion, error recovery). Tasks are persisted to disk and restored on extension reload, enabling long-running work across sessions. The checkpoint system captures task state at key points, allowing rollback to previous checkpoints if the agent makes mistakes. Task history is maintained in dual storage (in-memory for current session, disk for persistence).

Roo Code manages LLM context windows through a mention system where users explicitly include files, folders, or environment diagnostics via @-mentions in the chat. The system tracks context usage, calculates remaining tokens, and prevents context overflow by warning users when approaching limits. Context mentions are processed to extract file paths, resolve them relative to workspace, and include file contents or folder structure summaries in the prompt. Environment diagnostics (Node version, installed packages, etc.) can be auto-included based on settings.

Roo Code generates dynamic system prompts based on the current codebase, project structure, and user-selected mode (e.g., 'architect', 'test-writer', 'debugger'). The prompt assembly system combines base instructions, mode-specific guidelines, custom rules, and skill descriptions into a coherent system message. The system detects project type (Node.js, Python, web, etc.) and includes relevant tool descriptions and best practices. Custom instructions can be added per project or globally, and slash commands allow mode switching mid-conversation.

Roo Code implements an ask/say pattern where the agent can ask the user for clarification or approval before proceeding, and say messages to provide status updates or explanations. The agent uses special message types to request user input (ask) or provide information (say), which are displayed in the chat UI with appropriate styling. This enables interactive workflows where the agent pauses for user feedback rather than making autonomous decisions. Ask messages can include multiple choice options or free-form input fields.

Roo Code implements comprehensive error handling across API calls, tool execution, and task management with configurable retry logic. Failed API requests are retried with exponential backoff, tool execution errors are caught and formatted for the AI model to reason about, and task errors trigger recovery workflows. The system distinguishes between recoverable errors (rate limits, timeouts) and fatal errors (invalid API keys, permission denied), applying appropriate retry strategies. Error messages are formatted and included in the message history so the AI can learn from failures.

Roo Code implements a React-based webview UI that displays chat messages, tool calls, and agent responses in real-time. The UI supports message editing and deletion (with confirmation), streaming token display as they arrive, and rich formatting for code blocks, tool calls, and mermaid diagrams. The webview communicates with the extension host via a message protocol, synchronizing state bidirectionally. Messages are stored in dual storage (in-memory for UI state, disk for persistence), and the UI updates reactively as new messages arrive.

Roo Code maintains a skills system where each tool (native or MCP) has a description, usage guidelines, and examples that are included in the system prompt. Skills are organized by category and can be enabled/disabled per project. The system generates tool descriptions dynamically based on the tool's schema and includes them in the system prompt so the AI understands what tools are available and how to use them. Custom skills can be added via configuration, and skill descriptions are versioned with the extension.

Roo Code implements a slash command system where users can trigger special operations via commands like /architect, /test, /debug, etc. Commands are discovered from the system prompt and mode definitions, and executing a command switches the agent's mode or triggers a specific workflow. The command system integrates with the chat input autocomplete, showing available commands as the user types. Commands can have parameters and are validated before execution.