bytedance/UI-TARS-desktop

TARS is a multimodal AI agent framework that provides a composable architecture for building agents capable of GUI automation, code execution, and web research. It offers a desktop application, CLI tools, and a web UI to interact with these agents, supporting various operators for local and remote control of computers and browsers. The system integrates with multiple LLM providers and includes infrastructure for sandboxed execution, session management, and observability.

A new runnable example for the GUI Agent SDK 2.0 has been added to the \examples/gui-agent-2.0\ directory. This TypeScript-based demo demonstrates how to initialize a \GUIAgent\ with the \AIOHybridOperator\ and a Doubao model (via Volcengine Ark) to perform a simple task, such as checking the weather. The example includes the necessary source files (\src/index.ts\, \src/constants.ts\), configuration (\tsconfig.json\, \package.json\), and documentation (\README.md\, \quick-start-for-agent.md\) to guide users through setting up environment variables and running the agent.

examples/gui-agent-2.0 · high confidence

A new JsonRenderer component has been added to the common components library, allowing users to display structured JSON data in a styled, monospaced preformatted block with automatic syntax formatting and overflow handling.

multimodal/tarko/agent-ui/src/common/components · high confidence

The \multimodal/omni-tars/mcp-agent/src/tools\ directory now includes three new tool providers: \LinkReaderToolProvider\, \SearchToolProvider\, and \McpManager\. The \LinkReaderToolProvider\ exposes a \LinkReader\ tool that extracts content from URLs using the \text\_browser\_view\ MCP client. The \SearchToolProvider\ exposes a \Search\ tool that performs queries via the \google\_search\ MCP client. The \McpManager\ class centralizes MCP client initialization and defines client types (Tavily, Google, LinkReader, AIO), enabling these tools to interact with external MCP servers.

multimodal/omni-tars/mcp-agent/src/tools · high confidence

Users can now share their current conversation by copying the direct link or uploading the session to a provider to get a shareable URL, as well as downloading the conversation as a standalone HTML file. This change introduces the ShareButton and ShareModal components in the standalone UI, which handle the UI interactions and communicate with the backend share service endpoints.

multimodal/tarko/agent-ui/src/standalone/share · high confidence

A new ShareService has been introduced to enable session sharing capabilities. This service generates shareable static HTML content by leveraging the AgentUIBuilder and merging web UI configurations. It supports two modes: returning raw HTML locally or uploading the generated content to a configured remote provider. When uploading, the service processes workspace images, generates URL-safe slugs based on the first user message (with multilingual support), and appends a session hash to ensure uniqueness. The service is exported via the services index for use by the application.

multimodal/tarko/agent-server/src/services · high confidence

The \buildDomTree.js\ asset has been added to the browser-use package. This script provides the \window.buildDomTree\ function, which constructs a DOM tree representation of the current page while optionally highlighting elements with colored overlays and labels. It includes caching mechanisms for bounding rects, client rects, and computed styles to improve performance, and handles positioning for elements within iframes, enabling the agent to visually identify and interact with specific page elements.

packages/agent-infra/browser-use/assets · high confidence

The \multimodal/tarko/llm\ area now includes comprehensive documentation and code examples for integrating with major LLM providers. The main README introduces the \@agent-infra/llm\ TypeScript SDK, demonstrating how to initialize clients for OpenAI, OpenRouter, and Anthropic. The \examples\ directory provides reference implementations for OpenAI, Anthropic, and Gemini, covering basic chat, function calling, and image generation. Additionally, structured output examples are included for Claude 3.7 and Doubao, showing how to enforce JSON schemas and handle function calls via system prompts and API parameters.

multimodal/tarko/llm · high confidence

The \packages/agent-infra/mcp-client/examples\ directory now includes a \test.ts\ file demonstrating how to initialize an MCP client with various server types (browser, filesystem, commands) and convert MCP tools into formats compatible with OpenAI, Anthropic, and Azure OpenAI APIs.

packages/agent-infra/mcp-client/examples · high confidence

This location now includes a set of example scripts demonstrating how to use the BrowserSearch component. These examples cover basic search operations, headless mode, reusing browser instances across multiple queries, connecting to a remote browser via a CDP endpoint, and running benchmarks across Google, Bing, and Baidu search engines.

packages/agent-infra/search/browser-search/examples · high confidence

The \multimodal/agent-tars\ area now includes a dedicated CLI package (\@agent-tars/cli\) and a fully structured core package (\@agent-tars/core\). The CLI provides a command-line interface for Agent TARS, installable globally or via npx, and is built using rslib targeting Node.js. The core package exposes the main \AgentTARS\ class and includes examples for browser GUI agents, AIO sandbox environments, and various research tasks. Additionally, snapshot testing infrastructure has been added to the core package to capture and replay agent event streams.

multimodal/agent-tars · high confidence

The Agent TARS core module now includes a static WebUI configuration (\webui-config.ts\) that defines the default user interface settings, including a set of pre-configured welcome cards to guide users, a default 'narrow-chat' layout, and enabled features like the event stream viewer and screenshot render strategy switching. This configuration is exposed as a static property on the \AgentTARS\ class and exported via the main index, allowing the UI layer to consume these defaults without requiring runtime configuration overrides for basic setup.

multimodal/agent-tars/core/src · high confidence

The Agent TARS website is now available at agent-tars.com, providing a central hub for product information. The site features a documentation section with guides for quick starts, MCP configuration, and troubleshooting, alongside a blog covering announcements and technical deep dives into the Model Context Protocol. A showcase page highlights real-world use cases such as stock analysis and travel planning. The site is built with Rsbuild and React, includes Google Analytics tracking, and is optimized for SEO with comprehensive metadata and static HTML generation to ensure reliable routing.

multimodal/websites/main · high confidence

The agent server's storage layer has been refactored to support pluggable session storage backends, including in-memory, file-based (JSON), SQLite, and MongoDB. This change introduces an extensible JSON schema for session metadata, replacing the previous rigid column-based structure (e.g., separate name, tags, modelConfig columns) with a flexible metadata object, allowing future schema evolution without database migrations. Existing SQLite databases are automatically migrated to this new format during initialization, preserving all session and event data. Users can now configure the storage backend via the \AgentStorageImplementation\ options, enabling scalable deployments with MongoDB or persistent local storage with SQLite, while retaining backward compatibility for legacy session data.

multimodal/tarko/agent-server/src/storage · high confidence

Added a new script (\update-readme.ts\) that automatically generates and updates the API documentation section in the browser MCP server's README. The script connects to the server to list all available tools and resources, formats them into Markdown tables, and replaces the existing documentation block between specific HTML comments. This ensures the documentation stays in sync with the actual server capabilities without manual updates.

packages/agent-infra/mcp-servers/browser/scripts · high confidence

This change introduces core utility modules for the browser MCP server, establishing the foundation for reliable browser session handling and file operations. The new \browser.ts\ module implements logic to identify and manage the active browser tab by checking visibility and health, ensures a persistent browser instance is available (supporting both local and remote configurations), and configures essential settings such as ad-blocking, proxy authentication, and download behavior. Supporting utilities in \utils.ts\ provide helpers for parsing proxy credentials, validating selectors, sanitizing file paths, and generating download suggestions, while \file.ts\ adds a helper to ensure output directories exist.

packages/agent-infra/mcp-servers/browser/src/utils · high confidence

The browser-finder module in packages/agent-infra/browser now detects and locates Google Chrome, Microsoft Edge, and Mozilla Firefox across Windows, macOS, and Linux. It includes custom path-resolution logic for Chrome and Firefox (mimicking the structure of the existing Edge support) and implements a fallback strategy: when no specific browser is requested, it attempts to launch Chrome first, then Edge, and finally Firefox, ensuring the application can start even if only one browser is installed.

packages/agent-infra/browser/src/browser-finder · high confidence

The \multimodal\ directory is introduced as a new monorepo workspace, establishing the foundational project structure and developer tooling. This includes a \pnpm-workspace.yaml\ defining package scopes (such as \agent-tars\, \gui-agent\, \tarko\, and \omni-tars\), a root \tsconfig.json\ for TypeScript compilation, and a \vitest.config.mts\ for test execution across the workspace. Additionally, standard configuration files are added, including \.editorconfig\, \.gitignore\, \.npmrc\, \.prettierignore\, and \.prettierrc.yml\ to enforce code style and build artifacts exclusion, alongside a \pdk.config.ts\ for release and changelog management. Documentation is also provided via \README.md\ and \CONTRIBUTING.md\, which outline the package hierarchy and development setup instructions.

multimodal · high confidence

This change introduces the new \@agent-infra/shared\ package, providing foundational shared utilities for the agent infrastructure. It includes core agent components such as the \Message\ class (supporting system, user, assistant, and tool roles with serialization) and the \Memory\ class for managing conversation history with configurable limits. The package also exposes MCP tool definitions via the \MCPServerName\ enum (FileSystem, Commands, Browser) and re-exports common, browser, and agent-tars types to support broader application integration.

multimodal/tarko/agent-server, packages/agent-infra/browser-use, packages/agent-infra/shared/src · high confidence

The @tarko/agent package is now available as a standalone module, providing an event-stream driven meta agent framework for building multimodal agents. This release includes the core agent implementation, build configuration via rslib (supporting ESM and CJS outputs), TypeScript and Vitest test configurations, and comprehensive documentation. Users can now install and integrate the agent framework independently to leverage features like precise context engineering, multi-model compatible tool calls, and snapshot-based stability.

multimodal/tarko/agent · high confidence

The \@tarko/agent-cli\ package is introduced, providing a command-line interface for deploying and running agents built on the Agent Kernel. Users can launch an interactive Web UI, start a headless API server, or execute agents in silent mode via commands like \tarko run\, \tarko serve\, and \tarko request\. The CLI supports built-in agents (Agent TARS, Omni-TARS, MCP Agent) and custom agent scripts, with configuration managed through \tarko.config.{ts,yaml,json}\ files or CLI arguments. The package exports \defineConfig\ from \@tarko/interface\ and includes build-time metadata (git hash, build time) for debugging and identification.

multimodal/tarko/agent-cli · high confidence

The Tarko documentation website has been initialized, providing a comprehensive resource for developers. This includes a full API reference covering the Agent SDK, Agent Hooks, Tool Call Engines, and Agent UI Configuration, alongside practical getting-started examples for creating agents with custom tools and server integration. The site also features guides on advanced topics like Context Engineering, Agent Snapshots, and the Agent Protocol, as well as deployment instructions for CLI and server environments. Additionally, a CONTRIBUTING.md guide has been added to standardize documentation practices and ensure alignment between the docs and source code.

multimodal/websites/tarko · high confidence

This change introduces the core engine implementations for the browser search feature, adding new adapter classes for Google, Bing, Baidu, and Sogou. These engines handle generating search URLs, waiting for page loads, and extracting structured results (titles, URLs, and snippets) from the respective search result pages. A factory function (\getSearchEngine\) and an index file are also added to manage and export these engine instances.

packages/agent-infra/search/browser-search/src/engines · high confidence

The \@agent-infra/mcp-server-browser\ package is now available, providing an MCP server for browser automation via Puppeteer. It introduces a vision mode that captures screenshots in WebP format and supports coordinate-based clicking, alongside standard tools for navigation, tab management, and DOM interaction. The server supports both local and remote browser connections via CDP or WebSocket endpoints, configurable at runtime through HTTP headers or CLI arguments, and can be deployed via Docker or run as a remote SSE/Streamable HTTP service.

packages/agent-infra/mcp-servers/browser · high confidence

The new @agent-infra/browser package provides a TypeScript-based browser control library built on Puppeteer, designed for use within Agent Tars. It enables agents to launch local or remote browser instances, create pages, navigate to URLs, and capture screenshots. The package includes utilities for automated web search workflows, such as extracting search result links and parsing page content using Readability, and features auto-detection of installed browsers across platforms. This release also includes example scripts for bot detection, search, and screenshotting, along with ESM and CJS build configurations.

packages/agent-infra/browser · high confidence

The \packages/agent-infra/logger\ package has been added, providing a zero-dependency, isomorphic logging solution for both Node.js and browser environments. It features a \ConsoleLogger\ with colored output, hierarchical logging via \spawn\ for nested prefixes, and structured data logging with optional data transformation. The package includes full TypeScript support, configurable log levels (DEBUG through SILENT), and is built for ESM and CJS targets.

packages/agent-infra/logger · high confidence

A new MCP server package, @agent-infra/mcp-server-search, is added to enable web search capabilities. It exposes a 'web\_search' tool that supports multiple search providers including browser-based search, Bing, Tavily, SearXNG, and DuckDuckGo. The server can be run via stdio or SSE/Streamable-HTTP transports and allows configuration of the search engine, result count, API keys, and base URLs through command-line arguments or environment variables.

packages/agent-infra/mcp-servers/search · high confidence

The new @agent-infra/shared package provides common utilities for AI infrastructure projects. It is configured to build both ESM and CJS formats targeting the web, with TypeScript declarations and source maps enabled. The package includes standard configuration files for TypeScript, Vitest testing, and the rslib build tool, along with a CHANGELOG and README for installation and version tracking.

packages/agent-infra/shared · high confidence

Users can now install and run the new @gui-agent/cli package to automate GUI tasks via the command line. The CLI supports interactive setup or configuration via a local JSON file or remote YAML presets for Vision Language Model providers (OpenAI, Anthropic, VolcEngine, etc.). It allows users to target specific operators—desktop (via nut-js), web browser (Chrome), or Android (via ADB)—and execute automation instructions either through interactive prompts or direct command-line arguments. A 'reset' command is also provided to clear stored configuration.

multimodal/gui-agent/cli · high confidence

The new @gui-agent/operator-browser package provides a unified interface for controlling browser instances, featuring LocalBrowserOperator for managing local browser processes and RemoteBrowserOperator for connecting to remote browsers via WebSocket endpoints. Users can now leverage configurable visual feedback options such as clickable element highlighting, action information overlays, and water flow effects during screenshots, along with support for multiple search engines (Google, Bing, Baidu) for initial navigation. The package exports a comprehensive BrowserOperator class that supports a wide range of UI automation actions including clicks, typing, scrolling, and hotkey execution, all built on top of the @agent-infra/browser and @agent-infra/puppeteer-enhance libraries.

multimodal/gui-agent/operator-browser · high confidence

The new \@tarko/agent-interface\ package establishes the core protocol, types, and event stream specifications for the Tarko agent framework. For users, this introduces a standardized event system that now includes \ttftMs\ and \ttltMs\ performance metrics on assistant messages, as well as \messageId\ fields to properly correlate streaming and thinking events with their final responses. Additionally, the GUI agent action types (click, drag, scroll) have been updated to use percentage-based coordinates (0-1) instead of legacy absolute coordinates, and the agent constructor now supports a \webuiConfig\ property for dependency injection.

multimodal/tarko/agent-interface · high confidence

The new \@tarko/agent-ui-builder\ package provides a programmatic way to generate replay HTML files from agent session data. It exposes an \AgentUIBuilder\ class with a \dump()\ method to generate HTML (optionally saving it to a file) and an \upload()\ method to share the replay via a provider. The builder injects session events, metadata, and optional server/UI configuration into the static web UI, supporting both local static paths and remote HTML sources.

multimodal/tarko/agent-ui-builder · high confidence

The new \@tarko/agent-ui-cli\ package provides the \agui\ command-line tool, enabling users to generate interactive HTML replay files from agent trace data (supporting both JSON and JSONL formats). Users can customize the output using configuration files and apply custom transformers to convert non-standard log formats into the standard event stream. The CLI also supports uploading generated HTML to a sharing service for distribution.

multimodal/tarko/agent-ui-cli · high confidence

A new \@tarko/context-engineer\ package has been added to provide context engineering processors for Tarko. It introduces a \ContextReferenceProcessor\ that expands \@file:\ and \@dir:\ references in agent queries into actual file content and directory structures, including security checks to prevent path traversal attacks. Additionally, it includes an \ImageProcessor\ to compress base64 images in multimodal queries to reduce token usage, and a \WorkspacePack\ utility for high-performance, parallelized workspace content packing with filtering and deduplication.

multimodal/tarko/context-engineer · high confidence

The new @tarko/interface package provides high-level TypeScript interfaces and utilities for configuring the Tarko Agent Server and CLI. It introduces the defineConfig helper for type-safe application configuration, standardizes agent implementation types (markdown, module, modulePath), and defines storage backends (memory, file, sqlite, database, mongodb). The package also exposes server options, CLI argument definitions, and Web UI configuration interfaces, including layout controls, navigation items, and GUI agent rendering strategies.

multimodal/tarko/interface · high confidence

The new @tarko/llm-client package provides a TypeScript SDK that standardizes interactions with multiple Large Language Model providers—including OpenAI, Anthropic, Google Gemini, Mistral, Groq, AI21, Azure OpenAI, and generic OpenAI-compatible endpoints—under a single OpenAI-format interface. This library, forked from token.js to support multimodal and Azure capabilities, allows developers to configure a provider and model once and seamlessly switch between them while handling provider-specific nuances like streaming, tool calls, and image inputs automatically.

multimodal/tarko/llm-client · high confidence

The new @tarko/model-provider package provides a TypeScript SDK to configure and select from multiple OpenAI-compatible providers (including Ollama, LM Studio, Volcengine, and DeepSeek) via a unified interface. It automatically injects necessary 'anthropic-beta' headers for Claude models and applies specific experimental parameters for Azure OpenAI's Claude proxy service. Additionally, the model resolver now defaults unknown providers to 'openai-compatible' to support custom APIs, and allows runtime overrides for model and provider selection.

multimodal/tarko/model-provider · high confidence

A new shared utilities package (\@tarko/shared-utils\) is introduced, providing core helpers for the Tarko ecosystem. Most notably, it adds strict sanitization for session creation payloads (\sanitizeSessionAgentOptions\) and runtime settings (\filterDeclaredRuntimeSettings\) to prevent injection attacks—blocking dangerous keys like \mcpServers\ and \aioSandbox\ that could spawn local processes or redirect credentials. The library also includes utilities for deep object merging, item filtering, GUI agent action normalization, WebUI path routing, and server host resolution.

multimodal/tarko/shared-utils · high confidence

A new \@tarko/ui\ package has been added to provide reusable UI components and utilities for the Tarko Agent UI. This library exposes a set of basic components (such as \Dialog\, \ConfirmDialog\, \LoadingSpinner\, and \Tooltip\), AI-specific components (\ActionBlock\, \BrowserShell\, \ThinkingAnimation\), and code editing tools (\CodeEditor\, \MonacoCodeEditor\, \DiffViewer\). The package is configured for ESM output with TypeScript declarations and is intended to be installed via \pnpm add @tarko/ui\ to standardize UI elements across the application.

multimodal/tarko/ui, multimodal/tarko/ui/src · high confidence

Added a new ADB operator component that enables the GUI Agent to interact with Android devices via ADB. This operator supports taking screenshots (with fallback mechanisms for restricted apps), simulating touch gestures (tap, swipe, long-press), sending keyboard input, and retrieving screen context. It is packaged as \@gui-agent/operator-adb\ and includes an example test runner to demonstrate usage.

multimodal/gui-agent/operator-adb · high confidence

Adds a new \@gui-agent/operator-aio\ package that provides an All-in-One operator for remote computer control. This operator supports mouse operations (click, drag, scroll), keyboard input, hotkeys, and screenshot capture via a hybrid architecture: \AIOComputer\ handles actions through an HTTP-based sandbox client, while \AIOBrowser\ manages a remote browser instance for page navigation and visibility detection. The package includes a specialized \AIOGameOperator\ for game environments, a test runner example, and comprehensive unit tests for the computer actions.

multimodal/gui-agent/operator-aio · high confidence

The \agent-server-next\ module is introduced, providing a new server implementation built on Hono that features a priority-based middleware hook system for extensibility. This release adds critical security protections, including Host header validation to prevent DNS rebinding attacks, CSRF token validation for mutation requests, and a configurable CORS whitelist. It also includes built-in middleware for authentication, session restoration, request ID tracking, and access logging, along with example configurations for runtime settings and custom hook registration.

multimodal/tarko/agent-server-next · high confidence

This change adds the \@agent-infra/bing-search\ package, providing a lightweight, type-safe TypeScript client for the Bing Search API with zero external runtime dependencies, and updates the \search/examples\ directory to include runnable demonstrations for Bing, Browser, and Tavily search providers via a unified \SearchClient\.

packages/agent-infra/search/bing-search, packages/agent-infra/search/search/examples · high confidence

This change adds the \@agent-infra/mcp-server-commands\ package, an MCP server that allows users to execute arbitrary commands. It supports local execution via stdio (with an optional \--cwd\ argument) and remote access via SSE or Streamable HTTP (using the \--port\ argument, defaulting to 8089). The package includes configuration for the MCP official registry, Smithery, and build tooling for both ESM and CJS targets.

packages/agent-infra/mcp-servers/commands · high confidence

Added the \@agent-infra/duckduckgo-search\ package, providing a lightweight, type-safe TypeScript client for performing web searches via DuckDuckGo. This new tool allows AI agents to retrieve search results with configurable parameters such as query, result count, safe search settings, and time range. The client includes built-in retry logic for reliability and supports custom logging, enabling seamless integration into agent workflows for real-time information retrieval.

packages/agent-infra/search/duckduckgo-search · high confidence

The \multimodal/gui-agent/agent-sdk\ package is introduced, providing a new SDK for building GUI agents that interact with Android, desktop computers, and web browsers. The SDK supports multiple model providers including Anthropic Claude, OpenAI, and Volcengine ARK (Doubao/O-TARS), and includes example configurations for each combination. It features a configurable tool call engine, screenshot capture with automatic image detail calculation, and a test runner CLI for validating agent behavior against different operator backends.

multimodal/gui-agent/agent-sdk · high confidence

The \multimodal/omni-tars/gui-agent\ directory now contains the core implementation for the GUI Agent, including the \GuiAgentPlugin\ which handles browser interactions via an \OperatorManager\ and processes LLM tool calls through \GUIAgentToolCallEngine\. A key behavioral change is the introduction of automatic screenshot compression: the agent now compresses browser screenshots to WebP format (80% quality) before sending them to the model, and dynamically selects a \detail\ parameter ('low' or 'high') based on the compressed image's pixel count to optimize token usage. The \GUIAgentT5Adapter\ standardizes these actions into a \browser\_vision\_control\ format, and the plugin registers the necessary tools for the agent to execute GUI operations.

multimodal/omni-tars/gui-agent · high confidence

This change introduces the \@tarko/mcp-agent\ package and its \@tarko/mcp-agent-interface\ contract, providing an event-stream driven framework for building multimodal agents. Users can now configure MCP servers via stdio or HTTP/SSE transports and control which servers are active using the new \mcpServer\ filter options (\include\/\exclude\). The agent also exposes a \defaultConnectionTimeout\ option (defaulting to 60 seconds) to manage client connection lifecycles. The release includes example implementations for GitHub code review tasks across various model providers (Azure OpenAI, Volcengine/Doubao) and demonstrates tool filtering capabilities.

multimodal/tarko/mcp-agent · high confidence

Adds a new MCP Agent plugin that integrates Model Context Protocol (MCP) tools, specifically enabling web search via Tavily and Google, and web page reading via LinkReader. This change introduces the \McpAgentPlugin\ to manage MCP server connections, a custom \McpToolCallEngine\ to parse model responses containing \\<mcp\_env\>\ tags and tool calls, and a \McpToolCallEngineProvider\ to route tasks to this engine when MCP-related tools are detected. Users can now leverage these external data sources within the agent workflow.

multimodal/omni-tars/mcp-agent/src · high confidence

This change adds the foundational TypeScript type definitions for the MCP (Model Context Protocol) integration within the \mcp-shared\ package. It defines the \MCPServer\ union type, enabling configuration for stdio, SSE, streamable-http, and builtin server transports, along with support for configurable timeouts and tool/prompt filtering. Additionally, it introduces server-side types for tool schemas and results, providing the necessary structure for defining and handling MCP tools and prompts.

packages/agent-infra/mcp-shared/src · high confidence

Added a new \@gui-agent/operator-nutjs\ package that implements the \Operator\ interface using the NutJS library, enabling the GUI agent to interact with the local desktop environment. This operator supports screenshot capture (with high-DPI scaling), mouse actions (move, click, drag, scroll), keyboard input (type, hotkeys), and wait commands, providing the concrete backend implementation for desktop-based agent operations.

multimodal/gui-agent/operator-nutjs · high confidence

The Omni-TARS agent now uses a modular, plugin-based architecture that allows mixing and matching capabilities such as GUI interaction, code execution, and MCP tools. Users can now select from different agent modes (Omni, GUI, Game) to tailor the agent's behavior, with the Omni mode providing a comprehensive set of tools including web search, code sandboxing, and GUI control. The system supports configurable runtime settings, enabling users to adjust parameters like agent mode and browser control directly within the interface. Additionally, the agent includes pre-configured welcome cards for quick access to common tasks like playing games, researching topics, and writing code.

multimodal/omni-tars/omni-agent · high confidence

This location introduces the \@multimodal/seed-mcp-agent\ library, providing a configurable agent that integrates with OpenAI-compatible models and external tools via MCP (Model Context Protocol). The agent supports tool-calling capabilities, parsing structured responses for thinking, answers, and function calls (e.g., Search, LinkReader), and can be configured with API keys for services like Tavily and Google Search. The release includes example scripts demonstrating usage with OpenAI, Azure OpenAI (Claude), and direct MCP client connections, along with configuration files for building (rslib), testing (vitest), and development (tarko).

multimodal/omni-tars/mcp-agent · high confidence

The \agent-server-next\ module now includes a new controller layer that exposes endpoints for managing agent sessions, executing queries (both streaming and non-streaming with optional image compression and context reference expansion), and handling runtime settings. This includes creating and retrieving sessions, updating session metadata and model configurations, and managing user-specific configurations in multi-tenant environments. The system also supports sharing sessions via static HTML and provides health check and version information endpoints.

multimodal/tarko/agent-server-next/src/controllers · high confidence

The \packages/agent-infra/browser\ package is initialized, providing a browser automation library built on \puppeteer-core\. It introduces a \LocalBrowser\ class for controlling installed Chrome, Edge, and Firefox instances, and a \RemoteBrowser\ class for connecting to remote browser instances via WebSocket or CDP endpoints. The library includes a \BrowserFinder\ utility to automatically detect installed browsers, supports configuration options such as user data directories, proxy settings, and viewport dimensions, and implements a \BaseBrowser\ abstract class with page lifecycle listeners to manage active pages.

packages/agent-infra/browser/src · high confidence

Adds the core browser-use agent implementation in \packages/agent-infra/browser-use/src\, including the \Executor\ that orchestrates \Navigator\, \Planner\, and \Validator\ agents, along with the action schemas, model output definitions, and event management system required for automated browser interaction.

packages/agent-infra/browser-use/src · high confidence

The agent UI now uses a centralized \EventHandlerRegistry\ to manage and dispatch agent stream events. This new architecture registers specific handlers for user/assistant messages, tool calls, system events, and agent run lifecycle stages, allowing the UI to process these events consistently. Additionally, the system now supports an optional raw event stream viewer, which is conditionally enabled via configuration, and includes logic to skip specific streaming events during session replay to ensure accurate state restoration.

multimodal/tarko/agent-ui/src/common/state/actions/eventProcessors · high confidence

Developers can now use the \create-new-mcp\ command-line tool (via \npm create new-mcp@latest\, \yarn create new-mcp\, \pnpm create new-mcp\, or \bun create new-mcp\) to scaffold a new Model Context Protocol (MCP) server project. The generated template includes a TypeScript-based server implementation using the MCP SDK, support for both stdio and remote transports (SSE and Streamable HTTP), and configuration files for building with rslib and testing with Vitest. The scaffolded project also includes a \server.json\ manifest for MCP registry registration and a \smithery.yaml\ file for deployment on Smithery.

packages/agent-infra/create-new-mcp · high confidence

Users can now instantiate a specialized Code Agent that leverages the @agent-infra/sandbox infrastructure for secure code execution. This agent integrates three core tools—execute\_bash, StrReplaceEditor, and JupyterCI—driven by a custom CodeToolCallEngine optimized for code-related tasks. The engine detects code environments via tool names or \<code\_env\> tags and handles streaming responses to extract tool calls and content. A health check ensures the sandbox is reachable before operation, and the agent is exposed via a builder function for easy composition.

multimodal/omni-tars/code-agent/src · high confidence

The agent-ui now supports a new \autoActive\ property for navigation items, allowing embedded frames to be conditionally activated based on real-time runtime settings. Users can configure this with a boolean for static behavior or a JavaScript expression (e.g., \runtimeSettings.agentMode === 'game'\) that is evaluated against the current session's runtime settings. This feature is demonstrated in the new \webui-config.json\ example and documented in \runtime-settings-autoactive.md\, enabling more context-aware UI interactions.

multimodal/tarko/agent-ui · high confidence

The \mcp-http-server\ package now provides a high-performance server capable of serving Model Context Protocol (MCP) over both HTTP and Server-Sent Events (SSE). It supports Streamable HTTP transport (with configurable stateless or stateful modes) and SSE transport, allowing clients to connect via standard HTTP POST or persistent SSE streams. The server exposes configurable endpoints (defaulting to \/mcp\, \/sse\, and \/message\) and allows custom route prefixes. It passes HTTP request headers to the MCP server factory, enabling context-aware server creation, and supports custom Express middlewares for features like authentication. The package is built with TypeScript, supports both ESM and CommonJS outputs, and includes comprehensive tests for transport connectivity, header passing, and route configuration.

packages/agent-infra/mcp-http-server · high confidence

This change introduces two new packages: \@agent-infra/search\, an isomorphic client that unifies multiple search providers (Bing, Tavily, and Browser) under a single API, and \@agent-infra/browser-search\, a stealth-mode web search library built on Puppeteer. The \browser-search\ package supports multi-engine search (Google, Bing, Baidu), content extraction, and concurrent processing, while the \search\ package allows users to switch between providers seamlessly. Both packages are configured to build for ESM and CJS formats targeting the web environment.

packages/agent-infra/search/browser-search, packages/agent-infra/search/search · high confidence

This change introduces a new \BrowserSearch\ component within the agent infrastructure that performs web searches by launching a browser instance (local or remote via CDP endpoint) to scrape search engine results. Users can now execute search queries against configurable engines (defaulting to Google), with options to control concurrency, exclude specific domains (such as Reddit, Twitter, and YouTube), and retrieve either full page content or just snippets. The implementation includes stealth techniques to mimic a standard browser and handles result extraction and content truncation, providing a programmatic way for agents to gather information from the web.

packages/agent-infra/search/browser-search/src · high confidence

The \src/routes\ directory now contains explicit route definitions for the \agent-server-next\ service, establishing the API surface for session management, query execution, user configuration, system information, and CSRF token generation. This change introduces the structural wiring for endpoints such as \/api/v1/sessions\, \/api/v1/user\, \/api/v1/health\, and \/api/v1/csrf-token\, effectively defining the available API capabilities for this server component.

multimodal/tarko/agent-server-next/src/routes · high confidence

The \multimodal/tarko/agent-server-next/src\ directory now contains the source code for a new agent server implementation. This includes the main \AgentServer\ class built on Hono, which handles session management, DAO integration, and a hook-based middleware system. The package exports the server class, utility functions for logging, and type definitions for context variables and user information, establishing the core API surface for this new server architecture.

multimodal/tarko/agent-server-next/src · high confidence

The \infra\ area now includes the \pnpm-dev-kit\ (pdk) tooling, adding a new configuration file (\pdk.config.ts\) and a changelog (\CHANGELOG.md\) to the repository. This introduces support for automated release processes, including versioning, git tag management (with a \pdk@\ prefix), and changelog generation. The addition of the \pdk\ subdirectory and its associated build/test configs (TypeScript, Vitest, Rslib) establishes the infrastructure for these automated workflows, allowing for streamlined publishing and release branch creation.

infra · high confidence

UI-TARS Desktop now supports remote operation via a new remote operator implementation. This change adds the necessary client-side infrastructure to connect to and control remote sandboxes, including authentication logic for device registration and token signing, proxy clients for sending input commands (mouse, keyboard, screenshots) to remote instances, and subscription management for accessing remote browser sessions. Users can now leverage remote computing resources for UI automation tasks instead of relying solely on local execution.

apps/ui-tars/src/main/remote · high confidence

The \agent-server-next\ service layer now includes dedicated services for sandbox management and session sharing. The new \SandboxManager\ and \SandboxScheduler\ handle the creation, deletion, and intelligent allocation of sandbox instances (supporting Shared-Pool, User-Exclusive, and Session-Exclusive strategies) for agent sessions. Additionally, the new \ShareService\ enables users to generate shareable HTML snapshots of their sessions and upload them to external providers, while the \UserConfigService\ provides a DAO-backed interface for managing user-specific settings like sandbox quotas and allocation strategies.

multimodal/tarko/agent-server-next/src/services · high confidence

Added a new MCP filesystem server implementation that allows agents to read, write, edit, and search files within strictly defined allowed directories. The server enforces security by validating all paths against a whitelist and resolving symlinks to prevent directory traversal. It supports both standard stdio transport and network-based SSE/HTTP transport via the mcp-http-server library, configurable through command-line options for host and port.

packages/agent-infra/mcp-servers/filesystem/src · high confidence

The \agent-server-next\ package now includes a new \utils\ directory providing core support functions for the server implementation. This adds an agent resolution system (\agent-resolver.ts\) that dynamically loads agent modules by path or reference, and a configuration sanitizer (\config-sanitizer.ts\) that masks sensitive data like API keys and truncates instructions for safe UI display. It also introduces a structured error handling system (\error-handler.ts\) with standardized error codes and responses, an event stream bridge (\event-stream.ts\) to forward agent events to clients, and model utilities (\model-utils.ts\) to manage available models and filter sensitive metadata from session data. Additional utilities include an LLM-powered slug generator (\slug-generator.ts\) for semantic URL slugs, URL normalization (\url.ts\), and web UI configuration merging (\webui/config.ts\).

multimodal/tarko/agent-server-next/src/utils · high confidence

This change establishes a new shared library for the GUI agent, providing a standardized TypeScript SDK that defines core types (such as BaseAction, Coordinates, and ParsedGUIResponse) and abstract base classes for Agents, Operators, and Action Parsers. It includes utility functions to unify various action input names (e.g., mapping 'left\_click' to 'click') and serialize actions into string formats, as well as helpers for coordinate normalization and system prompt assembly. The package is configured to build both ESM and CommonJS outputs for Node.js environments.

multimodal/gui-agent/shared · high confidence

The core library now supports a modular, multi-agent system where distinct capabilities (code, MCP, and computer use) are implemented as independent plugins. A new \ComposableAgent\ orchestrates these plugins, dynamically generating system prompts and registering tools from all active environments. Additionally, a \ComposableToolCallEngine\ allows multiple tool-call backends to be registered and selected based on priority and context, enabling flexible model integration and streaming processing within the agent loop.

multimodal/omni-tars/core/src · high confidence

The chat interface now includes dedicated components to handle specific user states: EmptyState displays a modern prompt for starting conversations or replaying sessions with auto-play countdowns; OfflineBanner alerts users when disconnected and offers a reconnect button; ScrollToBottomButton provides a smooth, animated way to return to the latest messages; and SessionCreatingState shows an enhanced loading indicator while a new agent session is being prepared.

multimodal/tarko/agent-ui/src/standalone/chat/components · high confidence

The application now supports running the UI-Tars agent via a local browser (Chrome) or remote operators, in addition to the existing local computer mode. A new \browserCheck\ service verifies Chrome availability before execution, and the \runAgent\ service initializes the appropriate operator (LocalBrowser, RemoteComputer, or RemoteBrowser) based on user settings. This change also introduces support for the Responses API for model interactions and allows users to customize the search engine used by the local browser operator.

apps/ui-tars/src/main/services · high confidence

The \@agent-infra/mcp-client\ package introduces two key capabilities for users managing Model Context Protocol connections. First, it adds configurable timeouts, allowing you to control how long the client waits for responses from MCP servers, which helps prevent hangs in slow or unresponsive environments. Second, it provides a filtering mechanism for tools and prompts using glob patterns (allow and block lists), enabling you to restrict which server capabilities are exposed to your application. These features are documented in the new package README and tracked in the changelog starting from version 1.2.19 (filtering) and 1.2.20 (timeout).

packages/agent-infra/mcp-client · high confidence

A new \@common/electron-build\ package has been added to \packages/common\ to standardize Electron build and packaging workflows. It includes a \postMake\ hook that automatically generates the \latest-mac.yml\, \latest.yml\, and other platform-specific update manifest files required for auto-updates, ensuring these files are created alongside the build artifacts. The package also provides utility functions like \findUp\ and \getExternalPkgsDependencies\ to assist with module resolution and dependency analysis during the build process.

packages/common · high confidence

This release adds three new packages to the Tarko ecosystem. The \@tarko/agio\ package provides a standardized server-side monitoring protocol for AI agents, offering a consistent event schema and TypeScript utilities to track performance metrics, usage patterns, and operational health. The \@tarko/config-loader\ SDK enables applications to load configuration from various file formats (TypeScript, JavaScript, JSON, and YAML) with support for environment-specific logic and type safety. Additionally, the \@tarko/shared-media-utils\ package introduces an \ImageCompressor\ utility that allows for high-performance image compression to formats like WebP, JPEG, and PNG.

multimodal/tarko/agio, multimodal/tarko/config-loader, multimodal/tarko/shared-media-utils · high confidence

The \agent-cli/src/core\ module now provides the foundational CLI structure, introducing built-in agent support (Agent TARS, Omni Agent, MCP Agent) and the ability to filter tools and MCP servers via \--tool\ and \--mcpServer\ options. The CLI also adds an exclusive server mode to reject new requests while an agent is running, supports unknown option passthrough for agent-specific flags, and standardizes model configuration under the \--model\ namespace (including \--model.displayName\).

multimodal/tarko/agent-cli/src/core · high confidence

The agent server now introduces a dedicated \AgentSession\ class to manage individual agent execution contexts. This component handles the creation and initialization of agent instances, bridges agent events to clients via \EventStreamBridge\, and manages the persistence of session events to storage. It specifically filters out high-frequency streaming events (such as \assistant\_streaming\_message\ and \assistant\_streaming\_tool\_call\) from persistent storage to optimize replay performance, while ensuring that initialization events and other critical state changes are saved. The session also supports runtime settings transformation and AGIO monitoring event processing.

multimodal/tarko/agent-server/src/core · high confidence

The agent CLI now exposes a structured set of commands in the \core/commands\ module to manage workspaces, start servers, and run agent queries. Users can initialize and configure a global workspace (including selecting configuration formats like TypeScript, JSON, or YAML, and default model providers) via the new \global-workspace\ command. The \serve\ command starts the agent in headless API-only mode, while \start\ launches the interactive web UI, handling static file serving, URL generation, and automatic browser opening. Additionally, the \run\ command allows executing agent queries in either silent mode (outputting results directly to stdout) or server mode (using a temporary local server for one-shot requests), and the \request\ command provides a direct interface to send LLM requests to various providers with support for streaming and semantic formatting.

multimodal/tarko/agent-cli/src/core/commands · high confidence

This release introduces three new packages to the UI-Tars ecosystem. The \@ui-tars/cli\ package provides a command-line interface to run the UI-TARS agent, supporting both desktop (nut-js) and Android (ADB) operators with interactive configuration prompts. The \@ui-tars/action-parser\ package handles the parsing of model predictions, supporting both 'bc' and 'o1' modes, and includes logic for smart resizing and coordinate parsing for UI-TARS 1.5. Additionally, the \@ui-tars/electron-ipc\ package offers a type-safe, Zod-validated IPC solution for Electron applications, enabling seamless communication between main and renderer processes.

packages/ui-tars · high confidence

The agent server now includes a dedicated data access object (DAO) layer that abstracts storage operations for sessions, events, user configurations, and sandbox allocations. This layer supports both MongoDB and SQLite backends, allowing the system to persist agent state using either database engine. A factory function (\createDAOFactory\) handles the instantiation of the appropriate backend-specific DAOs based on configuration, providing a unified interface for session management, event logging, and user settings.

multimodal/tarko/agent-server-next/src/dao · high confidence

The application introduces a new set of IPC (Inter-Process Communication) routes in the main process to manage core functionalities. This includes an agent route for controlling the AI agent's lifecycle (run, pause, resume, stop) and managing conversation history, a browser route to check local browser availability, and a settings route that adds support for the OpenAI Responses API alongside the existing chat completions for model availability checks. Additionally, new routes handle remote resource allocation (for computers and browsers), system permission checks on macOS, screen size detection, and application window management including update checks.

apps/ui-tars/src/main/ipcRoutes · high confidence

Adds a new Model Context Protocol (MCP) server that enables agents to execute shell commands and run scripts on the host machine. The server exposes 'run\_command' and 'run\_script' tools, allowing users to specify the command, interpreter, and working directory. It supports both stdio transport for local use and SSE/HTTP transport via the mcp-http-server library, with the HTTP server defaulting to the loopback interface (127.0.0.1) for security. The implementation includes utilities for handling stdin piping, including a specific workaround for the fish shell, and structures output into standardized text messages for stdout, stderr, and errors.

packages/agent-infra/mcp-servers/commands/src · high confidence

This release adds a new example application, Open Operator, located in the examples/operator-browserbase directory. It demonstrates how to build a web agent using the UI-TARS SDK and Browserbase. The example includes a Next.js frontend with a chat interface, API routes for managing browser sessions and agent execution, and configuration files for environment variables and linting. Users can now run this example to see an AI agent interact with a headless browser via the Browserbase platform.

examples/operator-browserbase · high confidence

This update introduces a comprehensive set of new UI components and a code editor integration. The \basic\ directory adds foundational elements including \Dialog\, \ConfirmDialog\, \Dropdown\, \Menu\, \Select\, \Tooltip\, and \LoadingSpinner\, providing a consistent design system for user interactions. The \ai\ directory introduces \ActionBlock\ for displaying AI actions with status and timing, \BrowserShell\ for embedding browser-like views, and \ThinkingAnimation\ for visualizing AI processing states. Additionally, the \code-editor\ directory adds a \CodeEditor\ component for displaying code with syntax highlighting and line numbers, and a \DiffViewer\ component that integrates Monaco Editor to display file diffs with addition/deletion counts.

multimodal/tarko/ui/src/components · high confidence

The agent-ui now includes a set of new hooks in the common hooks directory to support enhanced user interface capabilities. The \useLayout\ hook centralizes control for the sidebar and workspace panel collapse states. A comprehensive replay system is introduced via \useReplay\ and \useReplayMode\, enabling users to playback agent sessions with auto-play countdowns, speed control, and file focus features. Session interactions are consolidated in \useSession\, which aggregates state for messages, tools, and connection status. Additionally, \useLogoType\ allows dynamic logo switching via URL parameters, \useThemeInitialization\ manages dark/light mode persistence, \useStableValue\ optimizes rendering performance for streaming content, and \useTool\ provides consistent iconography for AI tool calls.

multimodal/tarko/agent-ui/src/common/hooks · high confidence

Added a new action parser component for the GUI agent that parses LLM-generated action strings into standardized BaseAction objects. The parser supports multiple input formats including Omni format (with \<computer\_env\> and \<answer\> tags), BC mode (Thought/Action patterns), and OpenAI function call JSON format. It handles coordinate parsing from various formats (parentheses, brackets, XML tags like \<point\> and \<bbox\>), normalizes action types and parameter names, and validates required parameters. The component includes helper utilities for coordinate parsing, format-specific parsers (XML, Omni, UnifiedBC), and comprehensive test coverage for parsing edge cases including hallucination scenarios.

multimodal/gui-agent/action-parser · high confidence

The \multimodal/omni-tars/core/src/environments\ directory now contains dedicated TypeScript modules that define the system prompts and tool capabilities for the agent. \code.ts\, \computer.ts\, and \mcp.ts\ introduce specific environment definitions for code execution (including \execute\_bash\, \JupyterCI\, and \str\_replace\_editor\), computer use (GUI actions like \navigate\, \click\, \type\), and Model Context Protocol (MCP) functions (\Search\, \LinkReader\). \prompt.ts\ consolidates these into a unified system prompt, while \prompt\_t5.ts\ introduces mode-specific prompt generation logic that tailors the agent's behavior and available functions based on the \AgentMode\ (omni, gui, or game).

multimodal/omni-tars/core/src/environments · high confidence

The examples directory now includes comprehensive demonstrations of core agent capabilities. Users can learn how to abort running tasks (including streaming and concurrent scenarios), customize agent behavior using hooks like \onPrepareRequest\ and \onBeforeLoopTermination\, and configure various model providers such as OpenAI, Anthropic, Volcengine, and Azure OpenAI. Additionally, new examples cover tool call strategies (native, prompt engineering, structured outputs), image generation, and a planner agent implementing a plan-and-solve methodology.

multimodal/tarko/agent/examples · high confidence

The agent module now includes a new \NutJSElectronOperator\ class that handles screenshot capture via Electron's \desktopCapturer\ and manages text input on Windows using the clipboard, alongside a comprehensive set of system prompt templates (\prompts.ts\) defining action spaces and reasoning examples for UI-Tars v1.5, including specific configurations for Doubao models and a 'Poki' use case. These changes are accompanied by unit tests for the new operator's screenshot functionality.

apps/ui-tars/src/main/agent · high confidence

The agent runner has been restructured into a new modular pipeline consisting of LLMProcessor, LoopExecutor, ToolProcessor, and StreamAdapter. This change introduces a dedicated streaming adapter that converts internal agent events into an AsyncIterable for client consumption, supports runtime model switching via the LLMProcessor, and exposes new lifecycle hooks (onEachAgentLoopEnd, onPrepareRequest) allowing agents to dynamically modify system prompts and tools per iteration.

multimodal/tarko/agent/src/agent/runner · high confidence

The chat message input area now supports configurable agent runtime settings, allowing users to toggle and adjust options (such as browser, search, or thinking modes) directly within the session. This is implemented via new components like AgentOptionsSelector and ChatBottomSettings, which load and manage these settings from the API, and a new icon utility to visually represent them. Additionally, the input experience is improved with a new ChatInput component that integrates contextual file references (e.g., @file:, @dir:) and a dedicated inline image preview component (ImagePreviewInline) for better attachment management.

multimodal/tarko/agent-ui/src/standalone/chat/MessageInput · high confidence

The agent-server now includes a suite of new utility modules in src/utils to handle core agent lifecycle and security tasks. The agent-resolver module enables dynamic loading of agent implementations from module paths, respecting workspace directories for relative imports. A config-sanitizer utility masks sensitive data like API keys and truncates instructions for safe UI display, while model-utils provides functions to retrieve and validate available models, including a public-facing view that excludes secrets. Security is enhanced by a workspace-static-server that serves files with strict path-traversal protection and session isolation, and an error-handler that normalizes errors into structured responses to prevent process crashes. Additional utilities include an event-stream bridge for forwarding agent events to clients, an LLM-powered slug generator with multilingual support, and URL helpers.

multimodal/tarko/agent-server/src/utils · high confidence

The \@agent-infra/shared\ package now includes a new \browser\ module that provides tools for processing web page content. It introduces \extractPageInformation\ to pull readable titles and HTML content from a page using Mozilla's Readability algorithm, and \toMarkdown\ to convert HTML into Markdown format using Turndown with GFM support. These utilities are exported from the package's browser entry point, enabling consumers to easily parse and format web content within browser environments.

packages/agent-infra/shared/src/browser · high confidence

The agent CLI now uses a new configuration layer (src/config) that loads settings from a defined priority chain: CLI arguments, workspace config files (tarko.config.ts/yaml/json), global workspace configs, CLI config files, and remote URLs, with support for .env and .env.local files in the workspace. The builder merges these sources, handles deprecated CLI options (provider, apiKey, baseURL, shareProvider, thinking), and applies tool/MCP server filters, server options, and WebUI defaults. A new AGIO observability provider (src/agio) batches and sends agent lifecycle and runtime events to a configurable provider URL, improving telemetry performance. Configuration loading and merging are now logged in debug mode, with warnings for deprecated options.

multimodal/tarko/agent-cli/src/config · high confidence

The \multimodal/agent-tars/interface\ package now exposes a structured configuration system and CLI argument definitions. Users can define application settings using the new \defineConfig\ helper, which provides TypeScript type-checking for options including search providers (browser\_search, tavily, bing\_search), browser control modes (dom, visual-grounding, hybrid), and planning capabilities. The package also introduces \AgentTARSCLIArguments\ to standardize command-line input parsing, ensuring type safety by picking relevant fields from the main application config while maintaining backward compatibility for deprecated browser control shortcuts.

multimodal/agent-tars/interface · high confidence

The Agent Tars shared types package now exposes structured configuration interfaces for core features. Users can configure search via the new \SearchSettings\ type, which supports multiple providers (BrowserSearch, Bing, Tavily, Duckduckgo, SearXNG) and local browser engines (Google, Bing, Baidu, Sogou). Model configuration is defined by \ModelSettings\ and \ModelProvider\, explicitly including DeepSeek alongside OpenAI, Anthropic, Gemini, Mistral, and Azure OpenAI. Additionally, \MCPSettings\ and \FileSystemSettings\ are introduced to manage MCP server connections and file system access, all consolidated under a unified \AppSettings\ interface.

packages/agent-infra/shared/src/agent-tars-types · high confidence

A new benchmarking tool has been added to the \multimodal/benchmark/content-extraction\ directory to evaluate and compare different web content extraction strategies. The suite includes a \BenchmarkRunner\ that measures execution time, token count, and memory usage across four distinct strategies: a raw HTML baseline, the current Markdown implementation, a Mozilla Readability-based approach, and a new Optimized strategy using advanced content density analysis. Users can run these benchmarks against specific URLs to determine which strategy offers the best balance of performance and token efficiency.

multimodal/benchmark/content-extraction · high confidence

This change introduces three new utility files in the core package: \parser.ts\ adds logic to parse structured agent responses (extracting 'think' and 'answer' content and tool calls from code, MCP, and computer environments), \types.ts\ defines TypeScript interfaces for API responses, shell execution, Jupyter, and file operations, and \hepler.ts\ (sic) provides utilities for extracting AIO sandbox URLs/ports and generating timestamps.

multimodal/omni-tars/core/src/utils · high confidence

Added two new example configuration files (\conditional-visibility-settings.config.ts\ and \enhanced-runtime-settings.config.ts\) in the \examples\ directory that demonstrate how to configure runtime settings with custom UI placement (e.g., \chat-bottom\ vs \dropdown-item\) and localized enum labels. These examples show how to define conditional visibility for settings based on other options, apply global or per-setting placement overrides, and transform UI settings into agent-specific options via a \transform\ function.

examples · high confidence

The home page has been redesigned to include a new layout featuring welcome cards that allow users to quickly start specific tasks or modes (such as game mode) by selecting from categorized options. The session creation process now supports passing runtime settings and agent options from the home page, enabling persistent configuration across sessions or one-time options for specific tasks. Users can also directly start a chat from the home page, with the system handling session creation and message sending seamlessly.

multimodal/tarko/agent-ui/src/standalone/home · high confidence

The agent's tool-calling logic has been restructured into a modular engine system located in \multimodal/tarko/agent/src/tool-call-engine\. This change introduces three distinct implementations: \NativeToolCallEngine\ for models with native function-calling support, \PromptEngineeringToolCallEngine\ which uses a custom state machine to parse tool calls from text streams, and \StructuredOutputsToolCallEngine\ which leverages JSON schema constraints for structured responses. A shared utility, \buildToolCallResultMessages\, now handles the conversion of tool results into chat messages, differentiating between native protocols (separating text and non-text content) and non-native protocols (combining them). This architecture enables more robust streaming processing and better handling of multimodal tool results across different model capabilities.

multimodal/tarko/agent/src/tool-call-engine · high confidence

Added new shared UI components to the workspace: \MessageContent\ renders message text with support for markdown, short-message animations, and file display modes, while \ToggleSwitch\ provides a customizable two-state toggle UI with icons and labels. These components are now exported from the shared index for use across the application.

multimodal/tarko/agent-ui/src/standalone/workspace/components/shared · high confidence

The new \@agent-infra/shared\ package introduces a \PromiseQueue\ class that allows tasks to be executed with a configurable concurrency limit, ensuring sequential execution when needed and respecting error handling. Additionally, a build script is included to bundle the Mozilla Readability library into a constant for browser-side use.

packages/agent-infra/shared/scripts, packages/agent-infra/shared/src/common · high confidence

The sidebar has been redesigned with a new layout that includes a collapsible session list with search, grouping by date, and inline editing. A new Event Stream Viewer modal allows users to inspect and filter raw agent events for debugging. Additionally, an Agent Configuration viewer lets users inspect current agent settings, and a layout switch button toggles between default and narrow-chat modes.

multimodal/tarko/agent-ui/src/standalone/sidebar · high confidence

The workspace now includes dedicated UI components for rendering specific agent tool results, replacing generic displays with tailored views. This adds support for browser control and navigation (BrowserControlRenderer, BrowserResultRenderer), command execution with syntax highlighting (CommandResultRenderer), file viewing with mode switching for code, images, and markdown (FileResultRenderer), and structured content like diffs (DiffRenderer), deliverables (DeliverableRenderer), and research reports (ResearchReportRenderer). It also introduces renderers for embedded web frames (EmbedFrameRenderer), image previews with zoom/download (ImageRenderer), and link handling (LinkRenderer, LinkReaderRenderer).

multimodal/tarko/agent-ui/src/standalone/workspace/renderers · high confidence

The chat interface in the standalone agent UI has been restructured with new components: ChatPanel now manages the main conversation view with session state and scroll behavior; ContextualSelector and ContextualTags provide an enhanced file/directory picker with validation and visual feedback; ImagePreview adds a zoomable modal for uploaded images with improved styling and animations. These changes replace the previous renderer-based chat implementation with a more modular, standalone chat experience.

multimodal/tarko/agent-ui/src/standalone/chat · high confidence

The standalone UI now features a redesigned navbar that includes a model selector component, allowing users to view and switch between available AI models and providers directly from the navigation bar. An about modal has been added to display agent and model information, including the ability to copy model IDs and agent names. The navbar also supports workspace navigation items, embed frame toggling, and runtime settings integration, providing a more cohesive and informative user experience.

multimodal/tarko/agent-ui/src/standalone/navbar · high confidence

The application introduces a suite of new Jotai state atoms in the UI layer to support advanced interaction and debugging features. Users can now reference workspace files and directories directly in input using \@file:\, \@dir:\, and \@workspace\ tags, managed via the new \contextualSelectorAtom\. Session data is now isolated by ID, with dedicated atoms for messages (\messagesAtom\), files (\sessionFilesAtom\), and tool results (\toolResultsAtom\). Additionally, a new event stream viewer is supported by \rawEventsAtom\ and \eventStreamModalOpenAtom\, while the workspace display logic is unified under \workspaceDisplayStateAtom\ to handle embed frames and tool content. Global runtime settings and replay capabilities are also introduced via \globalRuntimeSettingsAtom\ and \replayStateAtom\.

multimodal/tarko/agent-ui/src/common/state/atoms · high confidence

The agent-ui now exposes a comprehensive set of TypeScript types in the common types module, defining the structure for session data (SessionInfo), conversation messages (Message, MessageGroup), tool results (ToolResult), and server connection status (ConnectionStatus). It also introduces a new TarkoMultimodalClipboardProtocol for cross-application data exchange and extends the global Window interface to support runtime configuration and event stream data from the agent server.

multimodal/tarko/agent-ui/src/common/types · high confidence

The \agent-ui\ application now includes a suite of new utility modules in \src/common/utils\ to support enhanced interaction and display capabilities. A new \clipboard.ts\ module enables multimodal clipboard support, allowing users to copy and paste text alongside images using the \tarko://webui/clipboard/v1\ protocol. A \tool-renderers\ system has been introduced to intelligently map agent tool outputs to specific UI components, featuring dedicated conditions for \read\_multiple\_files\ (rendered as a tabbed file viewer), \str\_replace\_editor\ (rendered as diffs or file results), and general content types like search results and images. Additionally, new utilities for formatting timestamps and relative dates, wrapping markdown, and handling model metadata and type guards have been added to standardize data presentation and improve code safety.

multimodal/tarko/agent-ui/src/common/utils · high confidence

The agent's utility layer has been expanded with several new modules to support advanced agent capabilities. A new \tool-filter.ts\ module allows users to include or exclude specific tools using pattern-based filtering. A standalone \LLMRequester\ class enables sending requests to LLM providers directly without instantiating a full agent, supporting both streaming and thinking modes. The \multimodal.ts\ module introduces logic to convert tool call results into multimodal formats, automatically extracting and embedding image data (PNG, JPEG, GIF, WEBP) from tool outputs for LLMs that support visual inputs. Additionally, \stream-utils.ts\ provides a function to reconstruct complete chat completions from streaming chunks, and \common.ts\ adds helpers for formatting tool parameters and converting Zod schemas to JSON Schema.

multimodal/tarko/agent/src/utils · high confidence

The agent-cli now includes a set of new utility modules in src/utils to support workspace and server operations. Workspace resolution has been enhanced with workspace-path.ts to handle relative, absolute, and home-directory paths, and workspace-config.ts to load instructions from .tarko/instructions.md. Server setup now includes port.ts and server-setup.ts, which automatically detect and switch to an available port if the configured one is in use. A new console-interceptor.ts allows capturing and filtering console output, useful for debugging or testing. Additional utilities include logo.ts for branded CLI output, misc.ts for environment variable resolution and path formatting, and index.ts to export all these utilities.

multimodal/tarko/agent-cli/src/utils · high confidence

The workspace interface now includes a dedicated file manager for browsing and filtering generated files, a terminal-style renderer for inspecting raw tool inputs and outputs with collapsible sections and copy functionality, and a share button that generates focus-based URLs for HTML and Markdown files in replay mode. HTML previews are now rendered in a sandboxed iframe using a dual-frame throttling strategy to ensure smooth streaming updates without blank frames, and a new fullscreen modal provides a secure, keyboard-accessible view for files with proper sandboxing to prevent script execution.

multimodal/tarko/agent-ui/src/standalone/workspace/components · high confidence

The standalone UI now includes a new application entry point (\AgentWebUI\) that initializes the theme and configures the router (switching between Hash and Browser modes based on replay state). The main \App\ component implements conditional rendering for the home page, creating page, and session views, respecting configuration flags to enable or disable the sidebar and home layout. Additionally, a new \ThemeToggle\ component has been added, allowing users to switch between light and dark modes via a button that persists the preference to local storage.

multimodal/tarko/agent-ui/src/standalone/app · high confidence

The UI Tars desktop application has been restructured into the apps/ui-tars directory with a new Electron Forge build configuration that includes auto-update support via app-update.yml, macOS code signing and notarization, and optimized bundle sizes. The build system now uses bytecode protection for private keys, Tailwind CSS for the renderer, and native module path resolution for screen capture permissions. New shared utilities for action overlays (setOfMarks) provide visual feedback for agent actions like clicks, typing, and hotkeys, while Playwright e2e testing infrastructure has been added.

apps/ui-tars · high confidence

The search module now provides a unified \SearchClient\ that standardizes search results across multiple providers, including Browser, Bing, Tavily, DuckDuckGo, and SearXNG. Users can configure the client with provider-specific settings (such as SearXNG's base URL or Tavily's API key) and receive a consistent \SearchResult\ format containing page titles, URLs, and content snippets, regardless of the underlying search engine used.

packages/agent-infra/search/search/src · high confidence

The \packages/action-parser\ package has been removed from the codebase. This deletion eliminates the standalone module responsible for parsing GUI agent predictions (extracting thoughts, reflections, and action parameters like coordinates) and its associated build configuration. This change is part of a broader monorepo migration to \apps/desktop\.

packages/action-parser · high confidence

The application has removed the entire legacy \src/main/agent\ module and its associated UI overlay components. This includes the \ComputerUseAgent\ loop, the \Desktop\ device abstraction (screenshot and input execution), the \UITARS\ LLM integration, and the \ScreenMarker\ system that displayed prediction overlays and pause buttons on the screen. Consequently, the hardcoded coordinate scaling \FACTOR\ and \MAX\_PIXELS\ constants, along with the \parseBoxToScreenCoords\ utility and its tests, have been deleted. The main process entry point (\main.ts\) and the Zustand store (\store/create.ts\, \store/runAgent.ts\) have been stripped of the code that initialized these agent and marker services, effectively disabling the previous GUI agent execution flow and its visual feedback layer.

src/main · high confidence

The entire \src/renderer\ directory has been deleted, removing the previous Chakra UI-based interface, routing, and agent execution hooks. This eliminates the old home, launcher, settings, and in-progressing pages, along with supporting components like ChatInput, ThoughtChain, and the useRunAgent hook, indicating a complete replacement of the renderer layer.

src/renderer · high confidence

The \packages/shared\ module has been removed, eliminating the previously exported type definitions (such as \Message\, \Status\, and \VlmResponse\), utility functions (including \generateShareId\ and \choose\), and the \tsup\ build configuration. This change indicates that the shared codebase is no longer maintained as a separate package, likely due to the monorepo migration to \apps/desktop\.

packages/shared · high confidence

The agent server API now includes robust security measures: CSRF protection with token generation, CORS origin whitelisting (including support for TARKO\_ALLOWED\_ORIGINS), Host header validation to prevent DNS rebinding, and automatic network authentication (Bearer token) when the server is externally reachable or explicitly configured. Additionally, a new one-shot query endpoint (/api/v1/oneshot/query) allows creating a session and executing a query in a single request, supporting both streaming and non-streaming modes. Session creation now returns initialization events, and runtime settings are properly filtered and persisted per session.

multimodal/tarko/agent-server/src/api · high confidence

The application now enforces stricter security by introducing a macOS entitlement file that explicitly allows JIT execution, while simultaneously implementing a secure IPC bridge in the preload script. This bridge exposes specific, limited methods for IPC communication, settings management, and state synchronization via contextBridge, replacing broader or less secure access patterns to ensure the renderer process interacts with the main process only through defined, safe channels.

apps/ui-tars/build, apps/ui-tars/src/preload · high confidence

The Agent TARS CLI now exposes build-time metadata, including the build timestamp and Git hash, via the \env.d.ts\ definitions and \versionInfo\ in the CLI entry point. Additionally, the CLI has added support for new browser control options (\--browser.control\ and \--browser.cdpEndpoint\) while marking the previous \--browserControl\ and \--browser-cdp-endpoint\ flags as deprecated, ensuring backward compatibility for existing users.

multimodal/agent-tars/cli · high confidence

The agent module has been restructured into a new event-stream driven architecture, introducing an \AgentRunner\ that coordinates specialized processors for LLM interactions, tool execution, and loop management. This change enables configurable reasoning modes (via the \thinking\ option), supports multiple tool call engines (native, prompt engineering, structured outputs), and allows users to set \maxIterations\ (defaulting to 1000) and \top\_p\ parameters. The new design also includes an \AgentExecutionController\ for managing abort signals and status, and an \AgentEventStreamProcessor\ that handles event persistence and subscription, allowing for better state management and replay capabilities.

multimodal/tarko/agent/src/agent · high confidence

The release workflow now includes a new script to automatically merge separate x64 and arm64 macOS update manifests into a single unified file, ensuring that users on either architecture receive the correct update metadata. Additionally, dedicated shell scripts have been added to streamline the publishing process, handling version updates, changelog generation, and npm publishing for both standard and beta package releases.

scripts · high confidence

The browser MCP server now supports a vision mode that uses screenshots instead of DOM snapshots, configurable ad-blocking, and the ability to connect to remote browser instances via CDP or WebSocket endpoints. Users can also customize the browser viewport, user agent, and context options, and the server provides a more robust tool interface with improved error handling and logging.

packages/agent-infra/mcp-servers/browser/src · high confidence

The code agent's tool implementations (execute\_bash, JupyterCI, and str\_replace\_editor) have been updated to use the AioClient from the @agent-infra/sandbox package instead of the previous omni-tars core client. This change introduces a fixed 2-minute timeout for bash execution and adds session state management for Jupyter CI commands, ensuring consistent behavior and better integration with the sandbox infrastructure.

multimodal/omni-tars/code-agent/src/tools · high confidence

The Agent UI now supports a more robust configuration system that loads settings from runtime injection, environment variables, or static defaults, with runtime taking precedence. This change introduces new configuration options to control the user interface layout, specifically allowing users to enable or disable the sidebar and home route via \webui.layout.enableSidebar\ and \webui.layout.enableHome\. Additionally, the system now supports configuring the \webui.base\ path for deployment flexibility and enables the Event Stream Viewer through debug settings, providing greater control over the UI appearance and debugging capabilities.

multimodal/tarko/agent-ui/src/config · high confidence

The agent UI now applies stricter security policies to HTML previews by defaulting to an opaque origin sandbox (removing \allow-same-origin\ for \srcdoc\ content) to prevent framed content from accessing the parent window's storage and APIs. Additionally, the application now exposes a centralized set of constants for API endpoints, environment configuration, local storage keys, and message roles, providing a single source of truth for these core values across the UI.

multimodal/tarko/agent-ui/src/common/constants · high confidence

The MCP client package now exposes a configurable default timeout (increased to 60 seconds) and supports filtering available tools and prompts via allow/block lists. This change also adds support for Streamable HTTP transports alongside existing SSE and Stdio, enabling more flexible server connections.

packages/agent-infra/mcp-client/src · high confidence

The application now includes an automatic update mechanism that checks for new versions on GitHub, downloads updates silently, and prompts the user to install them. Additionally, macOS permission logic for screen capture and accessibility has been refined: permissions are now explicitly reset when requested, E2E test environments bypass permission checks entirely, and warning messages have been simplified. Supporting utilities for agent lifecycle management, screenshot annotation, and screen size detection have also been added to improve core automation reliability.

apps/ui-tars/src/main/utils · high confidence

The agent server has been refactored to use a new \AgentServer\ class that orchestrates the Express application, HTTP server, session management, and storage integration. This change introduces support for exclusive mode (allowing only one active session at a time), configurable server authentication (requiring tokens when the server is not on loopback), and dynamic workspace resolution. It also adds TypeScript declarations for Express locals to expose the server instance and session data to request handlers, and integrates with the \@tarko/interface\ for global directory and logging configuration.

multimodal/tarko/agent-server/src · high confidence

The agent UI now processes real-time agent events through a dedicated handler system, replacing previous logic to improve state synchronization. This change introduces specific handlers for agent run lifecycle events (start/end), user and assistant messages (including streaming updates), tool calls and results, and system/environment inputs. It also adds a raw event capture mechanism to support the new Event Stream Viewer, ensuring all incoming events are stored for debugging and inspection. Additionally, utility functions have been added to manage file collection from tool outputs, normalize search results, and prevent cross-session content bleeding in the workspace panel.

multimodal/tarko/agent-ui/src/common/state/actions/eventProcessors/handlers · high confidence

The application's main store has been restructured to support new configuration capabilities, including the ability for users to customize their preferred search engine (Google, Baidu, or Bing) for browser operations. The store now manages a broader set of state properties such as \browserAvailable\ status and \sessionHistoryMessages\, and integrates with a new settings system that validates and persists user preferences like VLM providers (including support for Doubao-1.5) and operator types (Local/Remote Computer/Browser). This change also introduces the ability to import and apply remote or local preset configurations via YAML, ensuring that user settings for API endpoints, models, and operational loops are correctly validated and applied.

apps/ui-tars/src/main/store · high confidence

A new utility module has been added to the agent server to handle the merging of Web UI configuration. This change introduces a \mergeWebUIConfig\ function that combines the base Web UI configuration with any agent constructor Web configuration, ensuring consistent configuration merging across different contexts. This utility is exported from the \webui\ index file, making it available for use in other parts of the application.

multimodal/tarko/agent-server/src/utils/webui · high confidence

The PDK release command now supports direct version and tag specification via the \--release-version\ and \--release-tag\ flags, allowing users to bypass interactive selection for automated or scripted releases. Additionally, changelog generation and tag resolution now support a \--tag-prefix\ option (defaulting to 'v'), enabling the tool to correctly filter git tags in monorepos that use custom prefixes like 'pdk@' or '@agent-tars@'. These changes improve the reliability of release automation and changelog generation in complex monorepo setups.

infra/pdk · high confidence

The repository has been restructured and rebranded under the TARS umbrella, introducing two distinct projects: Agent TARS (a multimodal AI agent stack with CLI and Web UI capabilities) and UI-TARS Desktop (a native GUI agent application). The project license has been updated from MIT to Apache 2.0, and the README has been completely rewritten to reflect the new dual-project structure, documentation links, and feature sets.

(repo-wide) · high confidence

The chat interface has been refactored to improve streaming performance and visual clarity. The \MessageGroup\ component now renders each message independently to prevent blocking during streaming, while user messages containing both images and text are automatically split into separate visual blocks. A new \MessageFooter\ displays precise timing metrics (Time to First Token and Time to Last Token) alongside a copy-to-clipboard action. The \ModernThinkingToggle\ now features real-time duration tracking and animated states for active thinking processes. Additionally, new components have been introduced to handle specific content types: \SystemMessage\ for styled alerts, \MultimodalContent\ for image handling, and \ReportFileEntry\ for clickable research report links.

multimodal/tarko/agent-ui/src/standalone/chat/Message · high confidence

The standalone application layout has been updated with a new visual design and improved mobile support. On desktop, the chat and workspace panels are now wrapped in a new Shell component that provides consistent headers and styling, and the layout supports a 'narrow-chat' mode that adjusts the panel widths. For mobile devices, the interface switches to a single-column view where the workspace is accessible via a new MobileBottomSheet component, which allows users to drag the panel up or down and toggle it to fullscreen. Additionally, the layout now conditionally renders the EventStreamModal when the feature is enabled.

multimodal/tarko/agent-ui/src/standalone/app/Layout · high confidence

The standalone workspace area has been visually refreshed with a new design system featuring glass-card effects, elegant card layouts, and refined hover animations for a more polished user experience. The workspace now supports an embed-frame mode, allowing navigation items to be displayed as embedded views within the panel alongside standard tool content. Additionally, the workspace detail view has been updated to include a toggle for switching file display modes between source and rendered views, improving readability for code and markdown files.

multimodal/tarko/agent-ui/src/standalone/workspace · high confidence

The local browser control system has been restructured to use a Strategy pattern, introducing distinct modes—hybrid, dom, and visual-grounding—managed by a new BrowserToolsManager and StrategyFactory. This allows the agent to switch between DOM-based operations, vision-based GUI agent control, or a combination of both, with automatic fallback to DOM mode for providers that do not support vision (currently restricted to volcengine). Additionally, a new AIO Sandbox environment has been added that disables local browser operations and routes all tool functionality through an external MCP server, while the existing local environment now relies on this modular strategy framework for tool registration.

multimodal/agent-tars/core/src/environments · high confidence

The application's state management for sessions and connections has been restructured into dedicated action files (connectionActions.ts and sessionActions.ts). A key behavioral change is the optimization of the server health check polling: when the connection is already established, periodic checks now only refresh agent options rather than reloading the full session list, reducing unnecessary API calls. Additionally, session creation now processes initialization events returned by the server to immediately populate the UI state, and switching active sessions explicitly clears replay mode and recovers processing status to ensure accurate state.

multimodal/tarko/agent-ui/src/common/state/actions · high confidence

The auto-updater configuration file (app-update.yml) has been moved from the root resources directory to apps/ui-tars/resources to align with the monorepo structure. Additionally, the repository name in the configuration was corrected from 'ui-tars-desktop' to 'UI-TARS-desktop' to match the actual GitHub repository casing, ensuring the update check functions correctly.

apps/ui-tars/resources · high confidence

The static HTML file used for the UI TARS Visualizer report has been removed from the resources directory. This eliminates the large, embedded HTML/CSS bundle (approximately 20MB) that previously served as a standalone report viewer, likely shifting the responsibility for rendering or hosting these reports to a different component or external service.

resources · high confidence

The renderer application has been reorganized to use the shadcn/ui component library (configured via components.json with the 'new-york' style) and implements a new routing structure in App.tsx. A key behavioral change is the introduction of a local browser availability check in the SelectOperator component, which automatically switches the operator to 'LocalComputer' if a browser is not detected and provides a retry mechanism. The UI also includes new confirmation dialogs for session deletion, navigation, and termination, as well as a free trial agreement dialog for remote services.

apps/ui-tars/src/renderer · high confidence

The application's main process entry point has been established in apps/ui-tars/src/main/main.ts, initializing the Electron window, system tray, and IPC handlers. This change introduces automatic log file management, including archiving, size limits, and cleanup of old logs on startup, alongside new menu options to export, view, or clear these logs. The tray and menu interactions have been updated to use the new IPC routes for actions like stopping runs, and the app now checks for browser availability and handles remote preset updates upon launch.

apps/ui-tars/src/main · high confidence

The web UI now centralizes search logic through a new SearchService that normalizes results from Omni-TARS and web search tools into a consistent format, ensuring reliable display of search data. Concurrently, the API service has been hardened with CSRF protection for all mutation requests (POST/PUT/DELETE) and refined authentication handling that securely manages access tokens via sessionStorage, stripping them from the URL bar to prevent leakage while maintaining access for non-loopback servers.

multimodal/tarko/agent-ui/src/common/services · high confidence

This change introduces an auto-updater mechanism integrated into the main window and widget window via the AppUpdater class, enabling automatic update checks. It also fixes a visual bug on macOS where closing the main window in fullscreen mode would leave a black screen by ensuring the window exits fullscreen before hiding. Additionally, the traffic light position for macOS title bars has been adjusted from (16, 16) to (9, 9) for better alignment, and the widget window now includes content protection settings to prevent VLM models from capturing sensitive UI data.

apps/ui-tars/src/main/window · high confidence

The build process now correctly identifies external packages for native modules by platform (macOS, Windows, Linux) using a new script, which helps reduce the final bundle size by approximately 28%.

apps/ui-tars/scripts · medium confidence

The electron-updater module now includes a custom GitHub provider and utility functions to correctly handle pre-release channel logic (alpha/beta) when checking for updates and to properly resolve channel-specific YAML files (e.g., alpha.yml, beta.yml) from GitHub release artifacts. This ensures that users on pre-release tracks receive the correct update versions and that release notes are accurately fetched from the corresponding GitHub tag feed.

apps/ui-tars/src/main/electron-updater · high confidence

A patch for the pkce-challenge library (version 4.1.0) has been added to resolve a compatibility issue with Node.js 16. The change modifies the dynamic import of the node:crypto module to wrap the import statement in an async function, ensuring that the crypto object is correctly assigned in non-REPL environments on older Node.js versions.

patches · high confidence

Add agent snapshot testing infrastructure and baseline examples; Added API test coverage for contextual references, query execution, and security boundaries; Added Playwright-based E2E test suite for the desktop app; Added comprehensive test coverage for browser MCP tools; Added comprehensive test coverage for the Tarko agent core; Added comprehensive test suite for the Browser MCP Server; Added in-memory integration tests for the filesystem MCP server; Added integration and manual tests for MCP command execution; Added kernel-level agent tests; Added mock implementations for agent and Agio provider testing; Added test coverage for agent CLI configuration and event processing; Added test coverage for tool-call engine implementations; Added test files for Azure Bedrock Chat integration; Added test fixtures for multi-image event streams; Added tests for T5 streaming parser with think, chat, and tool call support; Added tests for agent session option boundary and event restoration; Added tests for model configuration utilities; Added tests for streaming parser tag handling; Added unit tests for MCPClient initialization and server management; Added unit tests for SQLite storage and exclusive mode middleware; Added unit tests for browser MCP server utility functions; Added unit tests for core parsing and tool call composition; Added unit tests for the browser HTML-to-Markdown conversion utility.

This change adds the \@gui-agent\ package scope, including the \@gui-agent/agent-sdk\ for core agent logic, \@gui-agent/action-parser\ for interpreting model outputs, and \@gui-agent/cli\ for command-line automation. It also introduces specific operators (\@gui-agent/operator-nutjs\, \@gui-agent/operator-adb\, \@gui-agent/operator-browser\, \@gui-agent/operator-aio\) to handle different interaction targets like desktop, Android, and web browsers. An example project (\examples/gui-agent-2.0\) is provided to demonstrate how to use these new SDK components.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 48 (+6.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 63 → 57 (-6.1)
• Architecture 62 (new)
• Maturity 61 → 79 (+18.5)
• Readiness 24 → 43 (+19.6)
• Security 57 → 66 (+8.4)
• Accessibility 43 (new)
• Performance 60 (new)

• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (infra/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (packages/ui-tars/visualizer/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (packages/ui-tars/visualizer/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (packages/ui-tars/visualizer/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (infra/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (infra/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (multimodal/pnpm-lock.yaml)
• High CVE: [GHSA redacted] (infra/pnpm-lock.yaml)
• …and 57 more

• AIOHybridOperator.singleActionExecutor (cognitive 22) (multimodal/gui-agent/operator-aio/src/AIOHybridOperator.ts)
• AIOHybridOperator.singleActionExecutor (cyclomatic 36) (multimodal/gui-agent/operator-aio/src/AIOHybridOperator.ts)
• AboutModal.AboutModal (cyclomatic 17) (multimodal/tarko/agent-ui/src/standalone/navbar/AboutModal.tsx)
• ActionBuilder.buildDefaultActions (cognitive 21) (packages/agent-infra/browser-use/src/agent/actions/builder.ts)
• ActionBuilder.buildDefaultActions (cyclomatic 19) (packages/agent-infra/browser-use/src/agent/actions/builder.ts)
• ActionParserHelper.parseRoughFromCallString (cognitive 17) (multimodal/gui-agent/action-parser/src/ActionParserHelper.ts)
• ActionParserHelper.standardizeAction (cyclomatic 16) (multimodal/gui-agent/action-parser/src/ActionParserHelper.ts)
• AdbOperator.execute (cognitive 37) (packages/ui-tars/operators/adb/src/index.ts)
• AdbOperator.execute (cyclomatic 46) (packages/ui-tars/operators/adb/src/index.ts)
• AdbOperator.singleActionExecutor (cyclomatic 18) (multimodal/gui-agent/operator-adb/src/AdbOperator.ts)
• AgentOptionsSelector.AgentOptionsSelector (cognitive 84) (multimodal/tarko/agent-ui/src/standalone/chat/MessageInput/AgentOptionsSelector.tsx)
• AgentOptionsSelector.AgentOptionsSelector (cyclomatic 82) (multimodal/tarko/agent-ui/src/standalone/chat/MessageInput/AgentOptionsSelector.tsx)
• AgentReplaySnapshotHook.onLLMRequest (cognitive 21) (multimodal/tarko/agent-snapshot/src/agent-replay-snapshot-hook.ts)
• AgentSnapshot.replay (cognitive 26) (multimodal/tarko/agent-snapshot/src/agent-snapshot.ts)
• AgentSnapshot.replay (cyclomatic 23) (multimodal/tarko/agent-snapshot/src/agent-snapshot.ts)
• AgentSnapshotNormalizer.normalize (cognitive 22) (multimodal/tarko/agent-snapshot/src/utils/snapshot-normalizer.ts)
• AgentSnapshotNormalizer.normalizeField (cognitive 18) (multimodal/tarko/agent-snapshot/src/utils/snapshot-normalizer.ts)
• AgentSnapshotRunner.cli (cognitive 28) (multimodal/tarko/agent-snapshot/src/agent-snapshot-runner.ts)
• AnthropicHandler.validateInputs (cognitive 23) (multimodal/tarko/llm-client/src/handlers/anthropic.ts)
• ApiService.sendStreamingQuery (cognitive 18) (multimodal/tarko/agent-ui/src/common/services/apiService.ts)
• …and 944 more

• 5 commits — 0 feature/other, 5 fixes

• multimodal/tarko — 4 commits
• multimodal/websites — 1 commit

• fix: fix(agent-server): block request-body injection into agent constructor options (#1939)
• fix: fix(agent-server): require a token once the server leaves loopback (#2026)
• fix: fix(agent-ui): stop html previews from escaping their iframe sandbox (#1938)
• fix: fix(docs): keep showcase pages working without the share API (#1937)
• fix: fix(security): validate Host header to prevent DNS rebinding in agent-server(-next) (#1975)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

bytedance/UI-TARS-desktop was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.