zhayujie/CowAgent

CowAgent is a multi-agent orchestration platform that manages teams of AI agents with isolated workspaces, persistent memory, and modular skills. It provides a unified interface for interacting with these agents across numerous messaging channels, including WeChat, Telegram, and Discord, while supporting a wide array of LLM providers and multimodal capabilities. The system features a self-evolution subsystem for autonomous learning, a comprehensive web console for configuration and monitoring, and native desktop and CLI clients for deployment and management.

36 changes.

The project rebranded to CowAgent, introducing a comprehensive multi-agent harness with unified web and terminal consoles, plugin extensibility, and robust deployment options. This period focused on expanding channel support across major IM platforms like WeCom, Feishu, and DingTalk, while standardizing voice processing and integrating diverse AI providers.

82 changes.

This period focused on evolving the system into a multi-agent platform with robust delegation, parallel sub-agents, and a comprehensive tool registry. It introduced extensive integrations for numerous LLM providers, voice services, and messaging channels, alongside a complete rewrite of the web console and the launch of a native desktop client.

This change introduces a new voice provider implementation for Alibaba Cloud, allowing users to enable speech-to-text and text-to-speech capabilities via Aliyun services. The \voice/ali\ directory now contains the integration logic (\ali\_voice.py\ and \ali\_api.py\) which handles API authentication, token management, and audio processing, along with a configuration template (\config.json.template\) for setting up the required API endpoints and credentials.

voice/ali · high confidence

Users can now use Azure Cognitive Services for speech-to-text and text-to-speech capabilities. The new \voice/azure\ module supports automatic language detection for text-to-speech synthesis, allowing the system to select appropriate neural voices for Chinese, English, Japanese, Korean, German, French, and Spanish, while also providing configurable speech recognition settings.

voice/azure · high confidence

Users can now interact with Baidu's Qianfan platform (ERNIE models) via a new bot integration. This adds support for text-based chat using the ERNIE-5.1 model and multimodal vision capabilities for image analysis using models like ERNIE-4.5-Turbo-VL. The integration handles session management, token counting, and API configuration via standard settings.

models/qianfan · high confidence

Users can now select Baidu or Youdao as translation providers. The Baidu translator supports automatic language detection and includes a 10-second request timeout with clear reporting of HTTP failures and API errors after retries. The Youdao translator implements the v3 signature scheme, maps ISO 639-1 language codes to Youdao-specific codes (including support for Cantonese), and validates responses to ensure translations are returned.

translate · high confidence

A new Banwords plugin has been added to the system, allowing users to filter sensitive words in both user messages and ChatGPT replies. The plugin supports two main actions: 'ignore' to silently drop messages containing banned terms, and 'replace' to mask sensitive words with asterisks and notify the user. It also includes a configurable 'reply\_filter' option to apply the same filtering logic to the AI's responses, with a default configuration provided in config.json.template and a sample word list in banwords.txt.template.

plugins/banwords · high confidence

Introduces a new Claude API bot implementation that supports both legacy 'enabled' thinking modes and the newer 'adaptive' thinking controls for Claude 4.6+ models (such as claude-opus-5 and claude-sonnet-5). The integration handles streaming responses, surfaces real provider token usage, and includes specific logic to manage thinking budgets and max\_tokens defaults for different model generations.

models/claudeapi · high confidence

Users can now use the DashScope API for speech recognition and text-to-speech via the new DashScopeVoice implementation, which supports the qwen3-asr-flash and qwen3-tts-flash models and handles audio format conversion for compatibility.

voice/dashscope · high confidence

Users can now use the Doubao (Volcengine Ark) API as a chat and vision model provider. This change introduces the DoubaoBot implementation, which supports text-based conversations with session management, image analysis via the vision endpoint (with a 180-second timeout), and configuration via the \ark\_api\_key\ and \ark\_base\_url\ settings. The default model is set to \doubao-seed-2.1-pro\, and the implementation includes error handling for rate limits and authentication failures.

models/doubao · high confidence

A new 'Dungeon' plugin is introduced, enabling users to play interactive text-adventure games via chat. Users can start a session with \$开始冒险\ (optionally providing a custom background story) and continue the narrative by sending messages, which the AI incorporates into the story. The game can be ended at any time with \$停止冒险\. The plugin is disabled by default and requires a compatible chat bot backend (such as OpenAI or ChatGPT). Additionally, a 'Finish' plugin is added to handle unknown command prefixes by returning an error message.

plugins/dungeon · high confidence

Users can now use Microsoft Edge TTS for text-to-speech conversion. A new EdgeVoice implementation has been added to the voice/edge module, leveraging the edge-tts library to generate audio files with default neural voices (e.g., zh-CN-YunjianNeural).

voice/edge · high confidence

Users can now generate voice responses using the ElevenLabs API. This change introduces a new voice provider that utilizes the \elevenlabs\ Python SDK (version 1.0.3) and the \eleven\_multilingual\_v2\ model. The implementation requires configuration of the \xi\_api\_key\ and \xi\_voice\_id\ in the application settings to enable text-to-voice conversion.

voice/elevent · high confidence

Users can now use Google services for voice interactions. The new GoogleVoice component enables speech-to-text conversion using the Google Speech Recognition API (defaulting to Chinese) and text-to-speech synthesis via gTTS. It also includes logic to generate unique filenames for audio outputs to prevent conflicts in multithreaded environments.

voice/google · high confidence

Introduces the 'Hello' plugin, which allows users to customize automated messages for group events such as new member welcomes, departures, and 'pat-pat' interactions via configurable prompts. It supports setting fixed welcome messages for specific groups and integrates with LinkAI character descriptions if enabled. The plugin also handles basic text commands like 'Hello', 'Hi', and 'End' (which triggers an image creation).

plugins/hello · high confidence

Users can now use the LinkAI platform for voice interactions, supporting text-to-speech via OpenAI, Doubao, and Baidu engines, and speech-to-text via Whisper, Doubao, or Baidu. The ASR engine is no longer hardcoded to Whisper-1; it respects the configured \voice\_to\_text\_model\ setting. Additionally, the TTS implementation now supports an optional \app\_code\ for workspace overrides and normalizes unsupported audio formats (like .silk) to .mp3 before sending to the API.

voice/linkai · high confidence

Users can now use MiniMax for text-to-speech synthesis. The new MinimaxVoice implementation connects to the MiniMax /v1/t2a\_v2 endpoint, supporting configurable models (defaulting to speech-2.8-hd) and voice IDs, and returns audio as hex-encoded MP3 chunks via SSE streaming.

voice/minimax · high confidence

Users can now interact with the MiniMax language model family. The new \MinimaxBot\ implementation defaults to the MiniMax-M3 model and enables native multimodal vision capabilities for image analysis. A dedicated session manager handles conversation history and token counting for this provider.

models/minimax · high confidence

Users can now interact with ModelScope AI models (defaulting to Qwen/Qwen3.5-27B) via a new bot integration. This feature supports standard text replies, streaming responses, and 'thinking' models that expose internal reasoning content. It also includes image generation capabilities and session management with automatic token-based context truncation.

models/modelscope · high confidence

Introduces the OpenAI voice backend (voice/openai/openai\_voice.py) to enable voice interactions using OpenAI's API. Users can now convert speech to text via the /audio/transcriptions endpoint (defaulting to gpt-4o-mini-transcribe) and convert text to speech via the /audio/speech endpoint (defaulting to the TTS-1 model). The implementation uses the native requests library instead of the OpenAI SDK, includes bounded request timeouts to prevent thread blocking, and ensures temporary audio files are properly managed.

voice/openai · high confidence

Introduces a new Telegram channel that enables users to interact with the agent via the Telegram Bot API. The implementation supports long polling, handles text, photos, voice, video, and documents, and provides a slash-command menu (help, status, context, tasks, skill, memory, knowledge, config, cancel, steer, logs, version) aligned with the Web interface. It includes a markdown-to-HTML converter to render rich text within Telegram's supported tag set, respects Telegram's message and caption length limits, and allows configuration of a bot token and optional HTTP/SOCKS5 proxy.

channel/telegram · high confidence

Users can now use the Xiaomi MiMo service for text-to-speech synthesis. A new \MimoVoice\ implementation has been added to the \voice/mimo\ module, which calls the MiMo \/chat/completions\ API to generate audio. This feature requires configuring the \mimo\_api\_key\ and optionally \mimo\_api\_base\ and \tts\_voice\_id\ in the application config. Note that speech recognition (voice-to-text) is not supported by this provider.

voice/mimo · high confidence

Users can now use the XunFei Spark AI service as a bot provider. This change introduces the XunFeiBot implementation in the models/xunfei directory, enabling text-based interactions via WebSocket with configurable API credentials (app\_id, api\_key, api\_secret) and model domains (defaulting to generalv3.5).

models/xunfei · high confidence

This change introduces a new voice provider, Xunfei, enabling the system to perform speech-to-text (ASR) and text-to-speech (TTS) via the Xunfei cloud APIs. The implementation adds \xunfei\_voice.py\ as the main adapter, \xunfei\_asr.py\ for handling streaming audio recognition, and \xunfei\_tts.py\ for generating audio files from text. Users must configure their Xunfei credentials (APPID, APIKey, APISecret) and business arguments in the new \config.json.template\ file located in the \voice/xunfei\ directory to enable these capabilities.

voice/baidu, voice/xunfei · high confidence

Users can now use ZhipuAI's BigModel API for voice interactions. This adds support for the glm-asr-2512 model for speech-to-text and the glm-tts model for text-to-speech. The implementation handles audio format conversion to MP3 for ASR compatibility and automatically detects the output audio format (WAV, MP3, OGG, FLAC) for TTS responses.

voice/zhipuai · high confidence

Introduces a new offline voice service using the Pytts3 library, allowing the system to convert text to audio files without external APIs. The implementation handles platform-specific initialization (Windows vs. Linux/macOS), sets default speech rate and volume, and ensures thread-safe file generation by using unique filenames based on timestamps and text hashes to prevent collisions during concurrent requests.

voice/pytts · high confidence

Users can now connect to the Xiaomi MiMo service via a new bot implementation. This adds support for the MimoBot class, which handles chat completions using the OpenAI-compatible protocol at api.xiaomimimo.com. The integration supports multiple model variants (mimo-v2.5-pro, mimo-v2.5, mimo-v2-pro, mimo-v2-omni, mimo-v2-flash), including multimodal capabilities for text, image, audio, and video. It also implements specific handling for the 'thinking' mode, where temperature and top\_p parameters are adjusted or stripped for certain models, and enforces the return of reasoning\_content in multi-turn tool calls as required by the API.

models/mimo · high confidence

Users can now use Tencent Cloud for voice services, including speech-to-text (ASR) and text-to-speech (TTS). This change introduces the \TencentVoice\ implementation and a configuration template (\config.json.template\) requiring Tencent Cloud credentials (SecretId, SecretKey) and voice type settings.

voice/tencent · high confidence

The banwords plugin now includes the WordsSearch module, which provides a trie-based algorithm for efficiently detecting and locating specific keywords within text. This addition enables the plugin to perform pattern matching against a set of defined ban words.

plugins/banwords/lib · high confidence

The models directory has been restructured to support multiple custom (OpenAI-compatible) providers via ID-based routing (bot\_type: "custom:\<id\>") while maintaining backward compatibility with the legacy single-provider mode. A new model catalog system allows per-provider model overrides and hidden presets, stored atomically to prevent data loss. Reasoning capabilities are now provider-specific, exposing native effort settings (e.g., low/high/max) for DeepSeek, Claude, Qwen, Kimi, and GLM models, with automatic handling of hybrid thinking models and Responses API routing for models like gpt-6-astra. The bot factory centralizes instance creation, and session management includes token-aware context trimming.

models · high confidence

The repository has been rebranded from chatgpt-on-wechat to CowAgent, introducing a comprehensive Agent Harness architecture. This release adds multi-agent team support with per-agent memory and workspaces, a Skills system for one-click tool installation, and a self-evolution subsystem for automatic memory distillation. A unified Web console (default channel) now serves as the central hub for chat, model configuration, and channel management. The platform supports a wide range of LLM providers (DeepSeek, Claude, GPT, Gemini, etc.) and integrates with multiple IM channels including WeChat, Feishu, DingTalk, Telegram, and Discord. Deployment is simplified via a one-line installer script (run.sh) and Docker support, with a new config template and extensive documentation.

(repo-wide) · high confidence

The desktop renderer now includes its foundational HTML shell and TypeScript asset declarations. Users will see the application load with a dark theme by default, respecting system preferences if configured, and the interface is structured to support a three-column layout with platform-specific branding. The renderer is also equipped to handle static assets like images and fonts locally without external CDNs.

desktop/src/renderer · high confidence

Adds a new 'ls' tool that allows users to list directory contents with support for relative and absolute paths, alphabetical sorting, and entry size limits. The tool includes security checks to prevent direct access to sensitive configuration directories (e.g., \~/.cow) and provides helpful error hints for path resolution issues.

agent/tools/ls · high confidence

The new Bash tool allows executing shell commands with platform-aware behavior: on Windows it uses cmd.exe (with PowerShell fallback for specific cases) and handles GBK/CP936 encoding to prevent mojibake, while on Unix it uses bash. It supports running long-lived processes in the background via run\_in\_background, with a registry to track, read, and kill jobs. Output is safely truncated and decoded, with soft exit codes (e.g., grep no matches) handled to avoid false failure reports. Security is enforced by blocking direct access to \~/.cow/.env and stripping sensitive environment variables. The tool also adapts its description and safety prompts based on the working directory and desktop mode.

agent/tools/bash · high confidence

The CowAgent CLI is now available as a standalone command-line tool (invoked via \cow\) for managing the agent instance. This release introduces commands to start, stop, restart, and check the status of the agent, as well as view logs. It includes a \cow update\ command that performs a one-click source update from GitHub (git pull, dependency install, and restart) for supported environments, and a \cow version\ command that reports the current version (2.1.9). Additional capabilities include managing skills and knowledge bases, performing portable data backups and restores, and installing browser tools (Playwright + Chromium). The CLI also supports localizing its output based on the user's configured language.

cli · high confidence

This change introduces the CowAgent Desktop application, a cross-platform Electron client built with React and TypeScript. It features a data-driven theme system that allows for platform-aware styling and customizable user bubbles, alongside a three-column layout. The release includes robust platform-specific code signing: macOS builds automatically sign nested Python backend binaries to satisfy Apple notarization, while Windows builds integrate a custom signing hook for all executables, supporting dry-run validation. The desktop client communicates with a local Python backend via HTTP and Server-Sent Events.

desktop · high confidence

Users can now connect to the DashScope API via a new bot implementation. This change adds support for Qwen3.5+ multimodal models (e.g., qwen3.8-max) by routing them to the MultiModalConversation API, while legacy models continue to use the standard Generation API. It also introduces a configurable base URL (dashscope\_api\_base) to support dedicated Bailian deployments and sets qwen3.7-plus as the default model.

models/dashscope · high confidence

A new 'Godcmd' plugin is added to the system, providing a command-line interface for both regular users and administrators. Users can authenticate via the \\#auth\ command using a password configured in \config.json\, after which they gain access to administrative commands such as \\#stop\, \\#resume\, \\#reconf\, and plugin management tools like \\#installp\, \\#uninstallp\, and \\#reloadp\. The plugin also exposes general commands like \\#help\ and \\#reset\ for session management, with help text dynamically generated based on user role and channel type.

plugins/godcmd · high confidence

Added a new Google Gemini bot implementation that enables text-based conversations and supports multimodal inputs via image markers (e.g., \[图片: path\]) embedded in user messages. The bot handles image processing by converting local files to base64 inline data for the Gemini API, manages session state, and includes logic to handle API errors and safety ratings. It defaults to the 'gemini-3.8-flash' model if no specific model is configured.

models/gemini · high confidence

Added a new LinkAI bot implementation (models/linkai/link\_ai\_bot.py) that integrates the LinkAI agent platform using an OpenAI-compatible interface. The integration includes robust API base URL normalization to prevent duplicate path segments (e.g., /v1/v1) and converts cryptic 404 errors into actionable configuration hints for users. It supports text and image creation contexts, manages sessions, handles client-specific metadata (client\_id, sender info), and includes specific error handling for authentication failures and rate limits.

models/linkai · high confidence

Adds the \linkai\ plugin, enabling integration with the LinkAI platform for three main capabilities: Midjourney image generation (with commands like \$mj\, \$mju\, \$mjv\, \$mjr\ and configurable rate limits), document summarization and multi-turn chat for files (txt, pdf, docx, etc.), sharing links (WeChat articles), and images, and knowledge base management that allows mapping specific group chats to different LinkAI applications via the \$linkai app\ command. The plugin includes a configuration template (\config.json.template\) for enabling/disabling features, setting API keys, and managing permissions, along with administrative commands (\$linkai open\, \$linkai close\, \$linkai sum open\) to control functionality dynamically.

plugins/linkai · high confidence

Users can now connect the agent to external MCP servers to expose additional tools. The system supports stdio, SSE, and Streamable HTTP transports, with a built-in OAuth 2.1 flow (PKCE) for remote servers that require authentication. Configuration is managed via a standard mcp.json file, validated by the console, and the agent uses on-demand vector-based retrieval to select relevant tools per conversation turn. Security is enforced by restricting environment variable inheritance for local subprocesses and persisting OAuth tokens securely.

agent/tools/mcp · high confidence

Added a new MoonshotBot implementation that supports Kimi-specific models including K2.x, K2.5, K2.6, K2.7-code, K3, and coding plans. The integration handles model-specific parameters such as stripping temperature/top\_p for K2.x/coding models, enabling deep reasoning via effort settings for K3/K2 models, and using a specific User-Agent for the Kimi Coding Plan. It also includes session management tailored for Moonshot's token limits and error handling for API failures.

models/moonshot · high confidence

Adds a new QQ Bot channel implementation that supports group chat (@bot), single chat (C2C), guild channels, and guild DMs. The channel handles text, images, files, and voice messages via a WebSocket long-connection. It includes auto-reconnection logic for silent connection drops and preserves original filenames for received documents. For voice messages, it automatically uses the QQ platform's ASR transcript to convert speech to text for immediate agent execution, falling back to caching the audio file if no transcript is available.

channel/qq · high confidence

Adds a new \wechat\_kf\ channel that allows external WeChat users to interact with the bot via WeCom Customer Service links or QR codes, distinct from the internal \wechatcom\ channel. The implementation handles asynchronous message synchronization using a persistent cursor stored in a local JSON file to prevent duplicate replies after restarts, and supports inbound text, image, voice, and file messages. Files and images are downloaded to the agent workspace's temporary directory to ensure agent tools can resolve relative paths correctly, and the channel includes logic to cache lone images so they are included in the context of the subsequent text turn.

_channel/wechat\kf · high confidence

Users can now connect the application to WeChat Official Accounts (both Subscription and Service accounts) via a new \wechatmp\ channel. This addition enables two-way interaction beyond simple text, supporting voice input (using WeChat's speech-to-text) and voice/image replies. The implementation handles WeChat's strict passive-reply timing constraints by caching responses and merging text segments, while also supporting AES message encryption and local file:// image URLs. It includes a custom client that manages API rate limits by automatically clearing quotas when exceeded, and is compatible with Python 3.13 by replacing the deprecated \imghdr\ module with manual image signature detection.

channel/wechatmp · high confidence

Adds the \wechatcom\_app\ channel, enabling users to connect the bot to a WeCom (WeChat Work) self-built application for receiving text, image, and voice messages. The implementation includes a custom client that proactively refreshes the \access\_token\ in a background thread to prevent expiration errors, splits long text replies into multiple messages, and handles voice conversion and splitting for audio files longer than 60 seconds. It also supports automatic image compression for large uploads and validates the corporate ID on callback endpoints to ensure security.

channel/wechatcom · high confidence

Adds a new WeCom (Enterprise WeChat) bot channel that supports both WebSocket long-connection and HTTP callback (webhook) transport modes. The implementation handles single and group chats, including text, image, file, and mixed message types, with automatic decryption of media payloads and storage in the agent's temporary directory. It also includes logic to tolerate invalid control characters in JSON payloads and manages stream states for callback-based interactions.

_channel/wecom\bot · high confidence

Adds a new Weixin channel implementation that enables the bot to connect to WeChat via the ilink bot protocol. This includes an HTTP API client for long-polling updates, sending messages, and handling QR-code login, as well as a channel handler that manages credentials, persists context tokens for scheduler reliability, and downloads media (images, files, voice, video) from the Weixin CDN into the agent's temporary directory. The implementation also lowers the TLS security level for CDN requests to ensure compatibility with legacy cipher suites.

channel/weixin · high confidence

The new common package establishes the runtime foundation for multi-agent coordination and cloud integration. It adds a process-wide channel manager registry to fix delivery bugs, a cloud client that enables agent hand-offs across different deployments via a LinkAI console, and a runtime identity system using ContextVars to track agent, user, and session context across threads. The update also introduces a global language resolution module supporting Simplified and Traditional Chinese, a token bucket for rate limiting, and SSL certificate fixes for PyInstaller builds.

common · high confidence

A new independent DeepSeek bot module has been added to handle DeepSeek API interactions, establishing \deepseek-flash\ (V4.1 Flash) as the default model. This module supports the full V4 series (\deepseek-v4-flash\, \deepseek-v4-pro\) and includes native multimodal capabilities for image understanding via \deepseek-flash\ and \deepseek-v4-flash-vision-exp\. It implements explicit thinking mode toggles and reasoning effort controls for V4 models, automatically stripping incompatible parameters like temperature during reasoning, and increases the vision request timeout to 180 seconds to prevent premature failures.

models/deepseek · high confidence

Adds a new agent/chat module that provides a ChatService for streaming agent responses via the CHAT protocol, a SessionService for managing conversation sessions (including AI-generated titles and context clearing), and a prompt optimization feature that rewrites user inputs into structured instructions using configurable rules from prompts.json. This enables richer, more reliable chat interactions with persistent session handling and improved input clarity.

agent/chat · high confidence

The agent/memory package now provides a unified memory system that combines long-term memory (vector and keyword search via SQLite and FTS5) with persistent conversation history storage. This includes a pluggable vector backend, heading-aware markdown chunking, and a memory flush manager that summarizes conversation context into daily records and periodically distills them into long-term memory (Deep Dream). Conversation history is now persisted in a global SQLite database, scoped by agent\_id, with support for session pinning, run attribution, and background integrity checks to prevent data loss or corruption.

agent/memory · high confidence

The web console is now delivered as a standalone channel (\channel/web\) that can be enabled by setting \channel\_type\ to \web\ in \config.json\ and listening on port 9899. The backend is restructured into a clear URL table (\web\_channel.py\) that wires 77 routes to per-view API modules (e.g., \api/chat.py\, \api/sessions.py\, \api/scheduler.py\) and shared core logic (\core/channel.py\, \core/\_common.py\). The frontend is split from monolithic files into concern-based fragments: server-side assembled HTML templates under \templates/\ (including views for chat, agents, config, skills, memory, knowledge, channels, tasks, and logs) and classic, defer-loaded JavaScript modules under \static/js/\ (with strict load-order rules to avoid temporal dead zone issues). Assets are versioned by file modification time to prevent stale caches, and vendor libraries are vendored locally without external CDN dependencies.

channel/web · high confidence

The agent can now spawn lightweight, in-process sub agents to handle self-contained tasks in parallel, keeping the main agent's context window clear of intermediate steps. Two built-in types are available: 'general-purpose' for multi-step work requiring both investigation and action, and 'explore' for read-only investigation. Sub agents operate with restricted permissions (inheriting the parent's permission mode but lacking memory persistence, identity, or messaging capabilities) and are governed by configurable limits for nesting depth, concurrency, and timeout. Users can define custom sub agent types by adding markdown files to the workspace's subagents directory, allowing for specialized roles with specific tool allowlists.

agent/subagent · high confidence

Users can now delegate self-contained tasks to in-process sub-agents via the new \SubagentTool\. This feature allows the main agent to spawn multiple sub-agents that run in parallel, each operating in its own context to complete specific goals. The tool provides real-time visibility into sub-agent progress through UI cards and step-level events, while returning structured results and summaries upon completion. This enables more efficient handling of independent work streams without blocking the main agent's execution flow.

agent/tools/subagent · high confidence

A new KnowledgeService is added to manage a structured knowledge base under the workspace, supporting nested directories, document creation, and import of .md/.txt files. The service automatically rebuilds knowledge/index.md from the actual directory tree to prevent drift, protects system files like index.md and log.md, and integrates with a shared embedding provider so that knowledge index synchronization utilizes vector search rather than degrading to keyword-only matching.

agent/knowledge · high confidence

The desktop application now features a native React-based renderer that provides a unified experience for managing agents, workspaces, and sessions. Users can now engage in multi-agent conversations, where they can select a specific agent as the conversation owner, invite teammates to group chats, and scope knowledge and memory pages to individual agents. The client includes a new workspace browser and preview panel for in-place file editing, a message navigator (ChatTimeline) for jumping between questions, and native OS features such as launch-at-login, auto-updates, and system-level notifications. Authentication is handled via a web-password gate, and the UI aligns closely with the web console, including a context-usage pie chart, streaming chat, and a composer with agent, model, and workspace selectors.

desktop/src/renderer/src · high confidence

The desktop application now features a complete native Electron shell that manages the backend lifecycle, system tray, and application menu. Users benefit from automatic background updates via electron-updater (with support for legacy Windows builds and China CDN mirrors), a data-driven theme system allowing bundled and user-provided themes, and native OS integrations including launch-at-login toggles, custom app icons, and system notifications. The shell also provides a generic HTTPS relay to bypass renderer CORS restrictions, robust backend health monitoring with specific error diagnostics, and persistent logging to a local run.log file for troubleshooting.

desktop/src/main · high confidence

A new \agent.protocol\ package has been added, establishing the core execution layer for the agent. This includes \AgentStreamExecutor\ for multi-turn tool-call streaming, \StepWriter\ for persisting run messages incrementally to prevent data loss on crashes, and \message\_utils\ for sanitizing and repairing broken tool-use/tool-result pairs in conversation history. The module also introduces \artifact.py\ to distinguish user-facing workspace files from internal agent bookkeeping, \cancel.py\ for thread-safe cancellation of in-flight runs, and \steer.py\ for active-run steering. Additionally, \agent.py\ now contains a version-gated model specification table (\\_MODEL\_SPECS\) that automatically resolves context windows and output caps for various LLM families (e.g., GPT-5+, DeepSeek V4+, Gemini, Claude, GLM, Qwen), ensuring correct token budgeting.

agent/protocol · high confidence

The application now supports a plugin system that allows users to extend functionality without modifying core code. Plugins can be installed, enabled, disabled, and reloaded at runtime via the Godcmd admin interface (using commands like \#installp, \#scanp, \#reloadp, and \#updatep). The system supports plugin prioritization to control execution order and provides a global configuration template (plugins/config.json.template) for managing settings. A curated list of available plugins, including tools for AI image generation (Midjourney, SD WebUI), news queries, and task management, is maintained in plugins/source.json.

plugins · high confidence

Added a new Edit tool that allows replacing exact text or appending to files, featuring automatic BOM stripping, line-ending normalization, and a credential guard that blocks edits to sensitive paths. The tool also includes syntax review before writing and handles fuzzy matching fallbacks for line-number prefixes.

agent/tools/edit · high confidence

A new background subsystem automatically reviews idle conversations to autonomously learn durable patterns, create or patch skills, and update memory or knowledge files. The feature is enabled by default, triggering after 6 turns or 10 minutes of idle time (or when context pressure is high), and uses a restricted, isolated review agent to make conservative changes. It includes safeguards such as file backups for instant rollback, workspace-level concurrency locks, and protection of built-in skills, while logging all changes to a dedicated evolution timeline for user visibility.

agent/evolution · high confidence

The \skills/skill-creator\ location now provides a comprehensive skill-creation workflow. The \SKILL.md\ file defines the rules and structure for building skills, including guidelines for organizing scripts, references, and assets. To support this, three new Python scripts have been added: \init\_skill.py\ generates a new skill template from a name and path; \quick\_validate.py\ checks skills for structural correctness (e.g., valid YAML frontmatter, naming conventions); and \package\_skill.py\ bundles a validated skill directory into a distributable \.skill\ zip file.

skills/skill-creator · high confidence

The new cow\_cli plugin intercepts chat messages to handle slash commands (e.g., /skill list) and 'cow' prefixed commands (e.g., cow skill list). It supports fuzzy command resolution to suggest corrections for typos, handles ambiguous inputs by prompting the user, and allows users to define custom command aliases via the config file. This enables a more robust and user-friendly command interface within the chat environment.

_plugins/cow\cli · high confidence

A new \AgentDelegateTool\ enables agents to delegate tasks to other teammates, supporting multi-hop delegation chains (up to a configurable depth) and synchronous execution. The tool includes a \DelegationPolicy\ for configuring allowed targets, timeouts, and message size limits. Delegated turns are relayed as distinct events in the transcript, preserving attribution to the specific teammate and ensuring that file or image replies from the delegate are correctly formatted and included in the final result returned to the delegating agent.

_agent/tools/agent\delegate · high confidence

The agent system now supports a modular Skills framework, allowing agents to discover, load, and execute specialized capabilities defined in markdown files with frontmatter. This change introduces a complete backend infrastructure for skills, including a loader that parses SKILL.md files and caches them for performance, a manager that handles the lifecycle and configuration of skills (including atomic config updates), and a service layer that exposes CRUD operations for viewing and editing skill definitions. The system enforces strict security by validating file paths to prevent traversal attacks during remote installation and ensures that skills are only included if their specific requirements (such as binaries, environment variables, or OS compatibility) are met. Users can now extend agent behavior by installing custom skills or configuring existing ones, with the system automatically integrating these capabilities into the agent's system prompt.

agent/skills · high confidence

The new tool plugin enables the chatbot to access external resources and perform actions beyond standard text generation. It supports a variety of tools including Python execution, web browsing (url-get, browser), terminal command execution, weather queries (meteo), and multiple search engines (Bing, Google, SearXNG, Wikipedia, Arxiv). Additional capabilities include news aggregation, image-to-text analysis (visual), text-to-speech, speech-to-text, and messaging via email, SMS, and WeChat. Users can configure specific tools and API keys via a config file, with a template provided for setup.

plugins/tool · high confidence

The agent now uses a centralized \ToolManager\ and a structured \agent/tools\ package to manage its capabilities. This introduces several new tools: \SearchFiles\ for searching file contents and names with a multi-backend strategy (ripgrep, grep, PowerShell, Python), \AgentDelegateTool\ and \SubagentTool\ for cross-agent and in-process task delegation, and \EvolutionUndoTool\ to roll back self-evolution changes. The system also integrates MCP (Model Context Protocol) tools via \McpTool\ and \McpClientRegistry\, and loads optional tools like \WebSearch\, \WebFetch\, \Vision\, \BrowserTool\, \EnvConfig\, and \SchedulerTool\ only when their dependencies are available. Base tool infrastructure includes \BaseTool\ with support for progress reporting, cancellation, and parallel execution flags.

agent/tools · high confidence

The system now supports multiple agents within a single runtime, each with its own isolated workspace and profile. A new team roster is persisted in a dedicated \team.json\ file (migrating legacy settings from \config.json\), enabling per-agent configuration of models, skills, and knowledge bases. Inbound messages are routed to specific agents based on channel instance bindings or explicit \@mentions\ in team conversations, with a fallback to the default agent. The registry ensures data isolation and validates agent identities, while the admin service manages the lifecycle and configuration of these agent profiles.

agent · high confidence

A new 'send' tool has been added to the agent's capabilities, allowing it to share local files (images, videos, audio, and documents) and remote URLs directly with the user. The tool resolves local paths relative to the workspace, determines file types and MIME types, and passes URLs through for inline rendering by the client. It also supports uploading local files to a cloud service when a website base URL is configured, enabling seamless file sharing across different environments.

agent/tools/send · high confidence

The CLI now includes dedicated command groups for managing agent backups (\cow backup\), controlling the agent process lifecycle (\cow start\, \stop\, \restart\), and installing skills from various sources including GitHub, GitLab, and local paths. The backup system supports multi-agent workspaces and cross-filesystem moves, while the process commands handle daemonization and PID tracking. Skill installation has been expanded to support batch installs, zip downloads, and secure extraction, with specific handling for different git providers and branch resolution.

cli/commands · high confidence

A new DingTalk channel implementation has been added, enabling the bot to receive text, images, rich-text, and file attachments (which are downloaded and cached for the agent). It supports streaming replies via DingTalk AI markdown cards, with a fallback to webhook markdown or plain text if cards are disabled or fail. The channel uses the DingTalk Stream mode, includes connection stability improvements with exponential backoff, and masks credentials in debug logs.

channel/dingtalk · high confidence

This change introduces a new Feishu channel implementation that supports both webhook and WebSocket event reception modes, configurable via \feishu\_event\_mode\. It adds support for receiving and processing rich message types including images, files, audio (voice), and rich-text (post) messages, with automatic downloading to the workspace temporary directory. The channel features streaming progress cards that display agent reasoning, tool execution steps, and accumulated text responses in real-time, as well as scheduler action cards for managing scheduled tasks directly within Feishu. It includes a one-click QR-scan app creation flow for simplified setup, lazy loading of the \lark\_oapi\ SDK to reduce startup time, and on-demand SDK bundle provisioning for desktop builds. The implementation also handles message recall events, group chat mention gating, and secure credential management.

channel/feishu · high confidence

A new 'Role' plugin has been added, allowing users to switch the bot's behavior to specific personas (e.g., 'Writing Assistant', 'Catgirl', 'Buddha') via commands like \$role\ or \$角色\. The plugin includes a built-in library of roles defined in \roles.json\ and supports fuzzy matching for role names. Users can also extend the library by placing custom JSON files in a \roles/\ directory, where files with matching titles override built-in roles and new titles are appended. The plugin supports filtering roles by tags and works with a wide range of supported AI backends.

plugins/role · high confidence

The repository now includes a comprehensive PowerShell installer script (run.ps1) for Windows that handles one-line installation, service management (start/stop/restart), and configuration. This script features internationalization (i18n) for Chinese and English UI, fixes for Windows-specific issues like console QuickEdit hangs and UTF-8 encoding, and simplified model selection menus. Additionally, new shell scripts (start.sh, shutdown.sh, tout.sh) are provided for Linux users to easily start, stop, and monitor the application's background process and logs.

scripts · high confidence

This change introduces a new ZhipuAI bot implementation (models/zhipuai) that adds support for ZhipuAI's GLM models, including multimodal vision capabilities and image generation. The integration allows users to configure a custom API base URL (e.g., for the international z.ai endpoint) via the \zhipu\_ai\_api\_base\ configuration. It features intelligent vision handling: if the main model is vision-capable (like glm-5.3-flash), it is used directly for image understanding; otherwise, it falls back to the dedicated glm-5v-turbo model. Additionally, the bot supports image creation via the CogView-3 model and includes session management with token-based message truncation to handle context limits.

models/zhipuai · high confidence

A new browser tool is introduced, allowing the agent to navigate web pages, interact with elements, and extract content using Playwright. The tool includes a security guard that blocks navigation to link-local and cloud-metadata addresses (SSRF protection) while preserving access to loopback and LAN targets for local development. It supports launching system-installed Chrome or Edge via the Chrome DevTools Protocol (CDP) to avoid automation permission prompts and persist login states across sessions, with a fallback to Playwright's bundled Chromium if no system browser is detected.

agent/tools/browser · high confidence

A new \env\_config\ tool has been added to the agent's toolset, allowing users to securely manage API keys and environment variables (such as OPENAI\_API\_KEY, GEMINI\_API\_KEY, and BOCHA\_API\_KEY) via 'set', 'get', 'list', and 'delete' actions. The tool stores configurations in a hidden \.env\ file within the \\~/.cow\ directory, automatically masks sensitive values in logs and responses, and supports hot-reloading skills immediately after changes are made.

_agent/tools/env\config · high confidence

A new 'Keyword' plugin has been added that matches user text input against a configurable list of keywords. When a match is found, the plugin replies with the configured content, supporting plain text, image URLs (including WebP), and video URLs. For downloadable files (PDF, Office docs, archives), it fetches the content to a temporary directory and sends the file to the user, with bounded timeouts and error reporting. Configuration is managed via a per-plugin config.json file.

plugins/keyword · high confidence

The agent now includes dedicated tools for accessing long-term memory and knowledge. The \memory\_search\ tool allows agents to find relevant information using semantic and keyword queries, while the \memory\_get\ tool enables reading specific content from memory or knowledge files with line-range support. These tools handle cross-platform path resolution and validate file access to ensure agents only read files within their allowed workspace or shared knowledge roots.

agent/tools/memory · high confidence

A new scheduler tool has been added to the agent tools, allowing users to create, manage, and execute scheduled tasks. The tool supports three scheduling types: cron expressions, fixed intervals, and one-time tasks. It enables the creation of static message reminders or dynamic tool-call tasks that execute other tools and send results. Tasks are stored in a global JSON file, and the system includes a background service to handle execution, along with features for listing, enabling/disabling, and deleting tasks. The tool also supports cross-channel delivery by maintaining a recipient store and allows for manual execution of tasks.

agent/tools/scheduler · high confidence

Agents now support three per-session permission modes—read-only, workspace-write, and full-access—that restrict tool actions (file writes, shell commands, browser interactions) based on the session's scope, with the new policy logic integrated directly into the system prompt so the model is aware of its constraints. The system prompt is now constructed by a new modular builder that assembles sections for tools, skills, memory, knowledge, workspace, permissions, and runtime info, ensuring the permission context is injected alongside the agent's capabilities.

agent/prompt · high confidence

A new \agent/tools/utils\ package introduces shared infrastructure for the agent's file and web tools. It adds a credential-path guard (\credentials.py\) that blocks access to sensitive files like \\~/.cow/.env\ and \/proc/\*/environ\ across all tools, not just the read tool. It includes robust diff and fuzzy-matching logic (\diff.py\) that preserves file indentation and line endings during edits. A staleness warning system (\file\_state.py\) alerts users if a file changes on disk between when the agent reads it and when it writes back. Memory indexing (\memory\_path.py\) is improved to correctly track writes in \knowledge/\ and \MEMORY.md\. Web fetching gains an opt-in SSRF guard (\url\_safety.py\) that blocks requests to private or loopback addresses when enabled. Finally, syntax validation (\syntax\_check.py\) prevents writing invalid JSON, YAML, TOML, or Python files.

agent/tools/utils · high confidence

The web console now features a redesigned layout with a dedicated sidebar for navigation (Chat, Agents, Config, Skills, Memory, Knowledge, Channels, Tasks, Logs), a top header with session history, workspace, and message navigator toggles, and a language/theme selector. Additionally, new modal dialogs have been added to support configuration and management tasks, including MCP tool editing (form and JSON modes), custom provider setup, skill installation (market and upload), knowledge document management, channel renaming, and execution record details.

channel/web/templates · high confidence

The web interface now includes a dedicated workspace panel that allows users to browse project directories, preview various file types (code, markdown, images, etc.), and edit text-based files directly in the browser. This change introduces new JavaScript modules (boot.js, doc-editor.js, workspace.js) to handle file management, inline editing with conflict detection, and session-scoped workspace access. Users can now view and modify memory files and skill definitions, and agent-generated file links will route to this new preview panel for immediate inspection and editing.

channel/web/static/js · high confidence

A new 'write' tool has been added to the agent's toolset, allowing it to create new files or completely overwrite existing ones. The tool automatically creates parent directories as needed and includes safety checks to prevent writing to credential files (such as \~/.cow/.env) and to reject content that resembles line-numbered output from the read tool. It also supports optional workspace confinement via configuration and integrates with the memory manager to mark the memory index as dirty when writing to memory-related files.

agent/tools/write · high confidence

Users can now assign a specific working directory (project) to a conversation, keeping file paths and previews scoped to that folder while memory and skills remain global. Additionally, each session can independently pin its own model, provider, and permission mode (e.g., workspace-write), allowing per-conversation customization without affecting other sessions or global defaults. The system also ensures that deleting an agent cleans up its associated project bindings and session preferences to prevent stale references.

agent/workspace · high confidence

Users can now route voice input (ASR) and output (TTS) through external vendors that implement the OpenAI audio API. This is configured via the \custom\_providers\ model, where each provider is identified by a unique ID and requires explicit \api\_base\, \api\_key\, and model settings. The system supports both the new \custom:\<id\>\ syntax and the legacy flat \custom\ type, allowing integration with third-party speech services without modifying core code.

voice/custom · high confidence

The multi-agent system now supports delegating tasks to teammates hosted in separate processes. This change introduces a transport layer (PeerTransport) that allows the local agent runtime to invoke remote agents, handle incoming hand-offs (delegated tasks, direct turns, or context clearing), and manage peer discovery. Users can now build team conversations where agents are distributed across different processes, with the local system acting as a gateway to these remote participants via the installed transport.

agent/multiagent · high confidence

The system now allows running multiple instances of the same channel type (e.g., multiple Feishu or DingTalk bots) simultaneously, each bound to a specific AI agent. This is configured via the new \channel\_instances\ list in \team.json\, which supports per-instance credentials, agent routing, and team delegation. The \channel\_factory\ and \channel\_instances\ modules handle the resolution of these instances, while the base \Channel\ class now supports instance-specific identity and credential overrides. Additionally, Discord and Slack channels have been added to the supported list, and the \ChatChannel\ base class has been refactored to use instance-level session queues to prevent cross-channel message interference.

channel · high confidence

The terminal channel has been updated to support real-time rendering of agent stream events, mirroring the experience of the web UI. Users will now see styled output for reasoning steps, tool calls (including arguments and execution results), file attachments, and errors, with ANSI color codes applied when running in a TTY environment. This change introduces the \TerminalAgentRenderer\ class to handle event types like \reasoning\_update\, \tool\_execution\_start/end\, and \message\_update\, providing immediate visual feedback during agent operations directly in the terminal.

channel/terminal · high confidence

The memory embedding layer has been restructured into a dedicated subsystem that centralizes provider configuration via a shared factory, ensuring consistent vector generation across agent initialization, knowledge sync, and index rebuilds. It now supports multiple vendors (OpenAI, LinkAI, DashScope, Doubao, Zhipu, and custom endpoints) with automatic fallback and explicit configuration, while also handling blank text inputs safely to prevent API errors. A new rebuild workflow probes the embedding endpoint before clearing the index to avoid leaving the system in a keyword-only state, and tracks chunker versions to suggest rebuilds when the indexing algorithm changes.

agent/memory/embedding · high confidence

Frontend assets (including Font Awesome, Inter font, Tailwind CSS, Markdown-it, Highlight.js, and D3) are now vendored locally in the static vendor directory. This allows the Web Console to function without external network requests, enabling use in fully offline or air-gapped environments where cloud services like Cloudflare or Google Fonts are inaccessible.

channel/web/static/vendor · high confidence

The web\_fetch tool has been expanded to handle not only HTML web pages but also remote document files (PDF, Word, Excel, PPT, and text formats). When a URL points to a supported document, the tool downloads and parses the content directly. Additionally, the tool now enforces strict SSRF (Server-Side Request Forgery) guards by validating URLs before fetching and re-validating every redirect hop, preventing requests to private or internal network addresses.

_agent/tools/web\fetch · high confidence

The web search capability is now a built-in tool that supports nine backends (Bocha, Qianfan, Zhipu, LinkAI, AnySearch, Serply, Tavily, SearXNG, and Keenable) with a unified response format. Users can configure specific providers via API keys or environment variables, or enable keyless modes for AnySearch and Keenable through explicit opt-in flags. The tool automatically selects the best available provider based on a configured priority order or allows users to fix a specific provider, ensuring robust fallback behavior if credentials are missing.

_agent/tools/web\search · high confidence

The bot factory implementation for the Baidu Unit service has been removed. The \bot\_factory.py\ file, which previously handled the creation of \BaiduUnitBot\ instances, is deleted, meaning the application no longer supports or instantiates the Baidu Unit bot channel.

bot · high confidence

The legacy WeChat channel implementation based on the itchat library has been removed from the codebase. This file previously handled message reception and sending for WeChat Personal accounts via QR code login; its removal indicates that this specific integration is no longer supported or has been replaced by other channel implementations.

channel/wechat · high confidence

The Baidu Unit bot implementation has been removed from the codebase, eliminating the ability to interact with the Baidu Unit API for chat responses.

bot/baidu · high confidence

The monolithic console.js has been split into distinct, focused modules (composer-input, context-usage, message-actions, new-chat, render, scheduler-notify, send, session-settings) to improve maintainability and separation of concerns. This refactoring preserves all existing user-facing capabilities—including drag-and-drop file uploads, slash command menus, context usage visualization, voice message support, multi-agent team chat, scheduled run notifications, and per-session settings—while organizing the underlying logic into cleaner, independent components.

channel/web/static/js/chat · high confidence

The web console's URL routing and request handlers have been reorganized into the channel/web/api directory. Individual modules now handle specific console views: agents (agents.py), authentication and MCP OAuth callbacks (auth.py), channel configuration (channels.py), chat messaging and streaming (chat.py), settings and provider configuration (config.py), file uploads and voice processing (files.py), knowledge base management (knowledge.py), log streaming and downloads (logs.py), memory files (memory.py), and model catalog management (models.py). This change consolidates the web API surface into a dedicated package structure.

channel/web/api · high confidence

The web console's internal structure has been refactored to improve maintainability and reduce coupling. Shared utilities, authentication logic, and configuration helpers have been consolidated into a new \\channel/web/core/\_common.py\\ module, which is now safely importable by both the channel logic and request handlers without creating circular dependencies. The main \\WebChannel\\ implementation has been moved to \\channel/web/core/channel.py\\, separating the core channel lifecycle and SSE streaming logic from the URL routing and request handlers. Additionally, a new \\channel/web/core/providers.py\\ module centralizes the vendor catalogue and model lists, removing the need for handlers to reach across each other for provider data. Finally, \\channel/web/core/template.py\\ introduces a server-side assembly mechanism for the console's HTML shell, using include markers to split the large \\chat.html\\ into manageable fragments while ensuring assets are versioned by modification time to prevent caching issues.

channel/web/core · high confidence

The monolithic console.js has been refactored into a modular script tree under channel/web/static/js/views/, separating concerns into dedicated modules for agents, channels, and configuration. This structural change improves maintainability and load organization for the web console interface.

channel/web/static/js/views · high confidence

A change to existing behaviour in bot/\_\pycache\\, channel/\\pycache\\_ — 2 commits, 4 files.

bot/\\pycache\\, channel/\\pycache\\, desktop/resources · medium confidence · unverified

The Baidu Wenxin integration previously crashed with an AttributeError when users sent image-creation commands, as the API does not support image generation. This change adds explicit handling for the IMAGE\_CREATE context type, causing the bot to return a standard error message stating that the bot does not support that message type, rather than failing silently or crashing.

models/baidu · high confidence

The monolithic console.css has been split into eight distinct stylesheets (agents, base, chat, components, knowledge, markdown, sessions, and workspace) to improve maintainability and load order management. This change reorganizes the web console's styling by area, ensuring that specific UI components like the agent roster, chat composer, and workspace panel are styled in isolation while preserving the existing visual design and layout behavior.

channel/web/static/css · high confidence

The web console's JavaScript has been refactored from a single monolithic file into a structured tree of core modules (auth, confirm, i18n, markdown, nav, notify, router, theme, utils). This change introduces address-bar routing that mirrors the current view and tab into the URL path, enabling proper Back/Forward navigation and deep linking. It also adds a new authentication gate that blocks background pollers until the user logs in, preventing unauthorized API spam, and implements cross-tab synchronization for task completion notifications using BroadcastChannel and localStorage to ensure only one notification per run is shown across all open tabs.

channel/web/static/js/core · high confidence

The bridge layer now supports an Agent-based conversation mode alongside the existing single-bot routing. A new AgentBridge subsystem (agent\_bridge.py, agent\_initializer.py, agent\_event\_handler.py) handles agent initialization, workspace isolation, memory sync, and event streaming, including a cap on intermediate thinking messages for WeChat channels. The core Bridge class (bridge.py) has been refactored to route chat requests to either the legacy bot factory or the agent bridge, and now implements a configurable chat fallback chain that walks through multiple provider/model links when the primary model fails. Additionally, bot\_type resolution was hardened to prevent AttributeErrors when model names are parsed as non-strings, and voice-to-text providers are auto-selected based on available API keys.

bridge · high confidence

The Docker deployment has been updated to use a new base image (python:3.10-slim-bullseye) and a new Dockerfile (Dockerfile.latest) that includes optional browser installation via Playwright for enhanced functionality. Configuration is now managed via environment variables in docker-compose.yml, with a default model set to deepseek-flash and web host bound to 127.0.0.1. Data persistence is improved by separating workspace (cow) and configuration data (cow-data) into distinct volumes, ensuring config.json and credentials survive container upgrades. The entrypoint script handles timezone configuration and ensures proper file ownership for the non-root agent user.

docker · high confidence

The OpenAI model implementation has been rewritten to remove the hard dependency on the \openai\ Python SDK, replacing it with a lightweight native HTTP client (\OpenAIHTTPClient\) that handles chat completions, image generation, and streaming. This change preserves existing error-handling behaviors (rate-limit backoff, timeout retries) via a compatibility layer (\openai\_compat\) that maps HTTP errors to familiar exception types. Additionally, a new \responses\_adapter\ module enables tool calling for models like \gpt-6-astra\ that require the OpenAI Responses API, translating standard chat messages into the required format. The bot also now injects attribution headers (e.g., \X-Title\, \HTTP-Referer\) for specific gateways like OpenRouter and Vercel AI Gateway, and tags requests with a client source for supported hosts.

models/openai · high confidence

The image generation skill now supports a unified script that automatically attempts image generation across multiple providers (OpenAI, Gemini, Seedream, Qwen, MiniMax, and LinkAI) in a defined priority order. It handles specific model families like gpt-image-2.5-flare, gpt-image-2, and various Gemini/Seedream models, while also implementing robust error handling by skipping empty response fields and falling back to alternative providers or formats when one fails.

skills/image-generation/scripts · high confidence

The voice module now uses a centralized factory to instantiate a wide range of text-to-speech and speech-to-text providers (including Baidu, Google, OpenAI, Azure, ElevenLabs, Ali, Edge, Xunfei, Tencent, MiniMax, DashScope, Zhipu, Mimo, and custom OpenAI-compatible endpoints) via a single abstract interface. Audio handling is standardized through a new conversion utility that supports decoding Silk files, converting between formats (WAV, MP3, AMR), and splitting long audio segments, ensuring consistent behavior across different voice services.

voice · high confidence

The vision capability has been refactored from a skill into a native tool, introducing a robust provider resolution system that prioritizes the main model for image recognition while automatically falling back to other configured providers (such as Moonshot, Doubao, DashScope, Claude, Gemini, Qianfan, ZhipuAI, MiniMax, MiMo, and DeepSeek) if the primary attempt fails. The tool now supports a wider range of multimodal models, enforces a 180-second timeout to prevent premature failures, and includes security hardening with SSRF guards for model-supplied URLs and path traversal protection. Users benefit from more reliable image analysis across diverse API configurations and improved security when processing external image sources.

agent/tools/vision · high confidence

The ChatGPT bot implementation has been rewritten to use the shared OpenAI-compatible HTTP client and error-handling layer, replacing the previous direct SDK usage. This change ensures consistent error handling and allows the bot to correctly resolve API credentials from specific custom providers (identified by \custom:\<id\>\) rather than relying on global configuration, preventing 404 errors when routing to non-OpenAI endpoints. It also adds support for new model variants (including GPT-5 series and o1) with appropriate parameter adjustments and improves session token counting accuracy.

models/chatgpt · high confidence

The desktop build process has been restructured to produce a self-contained backend bundle using PyInstaller, which now explicitly includes CLI command modules, document parsing libraries (PDF, Word, Excel, PPT), and the web console assets. To keep the initial download size small, the heavy Feishu SDK is excluded from the bundle and instead fetched on-demand as a trimmed, pure-Python package. The build also introduces macOS signing and notarization with device entitlements for microphone and camera access, and fixes a Windows issue where application updates would break desktop shortcuts by replacing the installer's staging move with an in-place removal and repair logic.

desktop/build · high confidence

Adds a new \agent/tools/read\ module that provides a dedicated file-reading capability for text, images, PDFs, and Office documents. The tool enforces security by blocking credential file access and bypassing \/proc/environ\ symlink attacks, handles Windows path and encoding differences, and corrects an off-by-one error in line counting for files with trailing newlines. It also supports PDF page ranges and retries knowledge-path misses under a shared root.

agent/tools/read · high confidence

Added development tools to validate console script load order and router behavior; Test suite isolation and multi-agent coverage.

This change introduces the \cowagent-desktop\ application (v2.1.9), a new Electron-based desktop client built with React, Vite, and TypeScript, featuring built-in auto-updates via \electron-updater\ and native macOS signing/notarization. It bundles a slimmed-down Python backend (\requirements-desktop.txt\) that supports Python 3.13+ by conditionally installing \web.py\ from GitHub and \legacy-cgi\, while also adding document parsing libraries (PDF, Word, Excel, PPT) and browser automation via Playwright. The main Python project dependencies (\requirements.txt\, \pyproject.toml\) are standardized to enforce Python 3.7+ compatibility, relax \numpy\ to \>=1.21, and pin specific versions for AI SDKs (e.g., \zai-sdk\>=0.2.3\ for GLM-5.3) and IM channels.

(dependencies) · high confidence

The static axios library has been updated to version 1.1.2, replacing the previous version in the web channel's static assets.

channel/web/static · high confidence

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

• CAI 39 → 41 (+2.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 47 → 46 (-1.5)
• Architecture 97 → 89 (-8.1)
• Maturity 67 → 65 (-1.1)
• Readiness 22 → 33 (+11.1)
• Security 48 → 54 (+5.3)
• Accessibility 42 (new)

• (anonymous) (cognitive 16) (channel/web/static/js/console.js)
• (anonymous) (cognitive 18) (channel/web/static/js/console.js)
• (anonymous) (cognitive 19) (channel/web/static/js/console.js)
• (anonymous) (cognitive 19) (channel/web/static/js/console.js)
• (anonymous) (cognitive 22) (channel/web/static/js/console.js)
• (anonymous) (cognitive 26) (channel/web/static/js/console.js)
• (anonymous) (cognitive 26) (channel/web/static/js/console.js)
• (anonymous) (cognitive 44) (channel/web/static/js/console.js)
• (anonymous) (cyclomatic 18) (channel/web/static/js/console.js)
• (anonymous) (cyclomatic 20) (channel/web/static/js/console.js)
• (anonymous) (cyclomatic 20) (channel/web/static/js/console.js)
• (anonymous) (cyclomatic 22) (channel/web/static/js/console.js)
• (anonymous) (cyclomatic 33) (channel/web/static/js/console.js)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (desktop/package-lock.json)
• Critical CVE: [GHSA redacted] (desktop/package-lock.json)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (channel/wechatcom/wechatcomapp_message.py)
• Duplicated block (10 lines × 2) (channel/wechatmp/wechatmp_channel.py)
• Duplicated block (10 lines × 2) (channel/wechatmp/wechatmp_message.py)
• …and 201 more

• (anonymous) (cognitive 25) (channel/web/tools/check-load-order.mjs)
• (anonymous) (cognitive 39) (channel/web/static/js/chat/composer-input.js)
• (anonymous) (cognitive 51) (channel/web/static/js/chat/state.js)
• (anonymous) (cyclomatic 30) (channel/web/static/js/chat/state.js)
• (anonymous) (cyclomatic 33) (channel/web/static/js/chat/composer-input.js)
• Agent._estimate_message_tokens (cognitive 18) (agent/protocol/agent.py)
• Agent.apply_project_dir (cognitive 16) (agent/protocol/agent.py)
• Agent.compact_context (cognitive 20) (agent/protocol/agent.py)
• Agent.get_context_usage (cognitive 26) (agent/protocol/agent.py)
• Agent.get_context_usage (cyclomatic 19) (agent/protocol/agent.py)
• Agent.run_stream (cognitive 22) (agent/protocol/agent.py)
• Agent.run_stream (cyclomatic 16) (agent/protocol/agent.py)
• AgentAdminService.create_agent (cognitive 21) (agent/admin.py)
• AgentAdminService.create_agent (cyclomatic 20) (agent/admin.py)
• AgentAdminService.set_knowledge_mode (cognitive 20) (agent/admin.py)
• AgentAdminService.update_agent (cognitive 26) (agent/admin.py)
• AgentAdminService.update_agent (cyclomatic 25) (agent/admin.py)
• AgentAvatar.AgentAvatar (cognitive 16) (desktop/src/renderer/src/components/AgentAvatar.tsx)
• AgentAvatar.AgentAvatar (cyclomatic 19) (desktop/src/renderer/src/components/AgentAvatar.tsx)
• AgentBridge._migrate_config_to_env (cognitive 26) (bridge/agent_bridge.py)
• …and 1516 more

• 300 commits — 115 feature/other, 185 fixes

• (repo) — 86 commits
• channel/web — 50 commits
• agent/tools — 15 commits
• desktop/src — 13 commits
• agent/memory — 11 commits
• agent/chat — 8 commits
• agent/protocol — 7 commits
• channel/dingtalk — 7 commits
• channel/feishu — 7 commits
• (root) — 6 commits
• agent/prompt — 5 commits
• bridge/agent_initializer.py — 5 commits
• channel/qq — 5 commits
• agent/multiagent — 4 commits
• bridge/agent_bridge.py — 4 commits
• cli/commands — 4 commits
• common/cloud_client.py — 4 commits
• channel/wecom_bot — 3 commits
• channel/weixin — 3 commits
• agent/skills — 2 commits

• fix: Merge pull request #3144 from c020627/fix-baidu-wenxin-image-create
• fix: Merge pull request #3147 from c020627/fix-baidu-translate-retry-exhausted
• fix: Merge pull request #3149 from c020627/fix-silk-to-mp3-source-overwrite
• fix: Merge pull request #3150 from c020627/fix-linkai-media-url-classification
• fix: Merge pull request #3151 from c020627/fix-mj-send-retry-recursion
• fix: Merge pull request #3152 from c020627/fix-linkai-asr-format-conversion
• fix: Merge pull request #3159 from c020627/fix-wechatcomapp-callback-corp-id
• fix: Merge pull request #3164 from SummerCaptain/fix/memory-hybrid-fusion
• fix: Merge pull request #3169 from c020627/fix-registry-pin-leak-between-tests
• fix: Merge pull request #3172 from zkjqd/fix/knowledge-empty-state
• fix: Merge pull request #3173 from c020627/fix-feishu-group-post-mention-gate
• fix: Merge pull request #3177 from c020627/fix-web-multipart-agent-scope
• fix: Merge pull request #3181 from cowagent/fix/macos-media-entitlements
• fix: Merge pull request #3189 from liuns-yang/fix/scheduler-utc-timezone
• fix: Merge pull request #3193 from c020627/fix-wecom-bot-group-mention
• fix: Merge pull request #3194 from yetuge/docs/fix-readme-links
• fix: Merge pull request #3198 from c020627/fix-wecom-bot-media-tmp-dir
• fix: Merge pull request #3200 from zyc2022/fix/backup-cross-device-output
• fix: Merge pull request #3201 from c020627/fix-windows-home-isolation-in-tests
• fix: Merge pull request #3203 from fuxicodex/fix/ci-flaky-tests
• …and 280 more

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

zhayujie/CowAgent 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.