HKUDS/DeepTutor

DeepTutor is an agentic educational platform that orchestrates a wide range of learning capabilities, including interactive chat, deep research, problem solving, and structured book generation. It integrates with diverse knowledge sources such as Obsidian, MarginNote, and external APIs, while providing specialized tools for document parsing, code execution, and visualization. The system supports multi-user environments with role-based access, allowing for collaborative learning, guardian oversight, and personalized AI personas across web and CLI interfaces.

Users can now automatically sync Markdown content from GitHub repositories into their Knowledge Bases. This change introduces a new background service that periodically pulls Markdown files from specified GitHub repos (supporting branch, path prefix, and glob filtering) and updates the KB's raw data directory. It includes an async GitHub API client for fetching file trees and diffs, with support for private repositories via the GITHUB\_TOKEN environment variable, and handles incremental updates to minimize API usage.

_deeptutor/services/github\source · high confidence

Users can now select LiteParse as a document parsing engine, which converts PDF, Office, and image files into Markdown using a Rust-backed, in-process parser that requires no model weights or CUDA. This engine supports a wide range of input formats (including .docx, .pdf, .pptx, and various image types) and allows configuration for image extraction modes (off, placeholder, or embed), link extraction, and page limits, while adhering to the existing workdir contract for Markdown output and image assets.

deeptutor/services/parsing/engines/liteparse · high confidence

Users can now connect a MarginNote 4 library as a knowledge base, enabling DeepTutor to perform agentic retrieval over synced study data. When a MarginNote 4 library is selected, the chat loop switches to a dedicated set of seven tools (search, read, list, documents, links, tags, and cards) that query a local SQLite store of synced notes, excerpts, flashcards, and mindmap nodes, allowing the model to navigate the study graph and answer questions grounded in the user's personal library.

deeptutor/capabilities/marginnote4 · high confidence

DeepTutor now supports connecting to Tencent IMA knowledge bases for retrieval-augmented generation. Users can bind an IMA library via account-level or per-knowledge-base credentials, enabling document search, inventory browsing, and full-text content extraction (including notes and files) without local indexing. The integration includes a connect-time health check to validate credentials and knowledge base IDs, a cached inventory reader for listing library contents, and strict security boundaries for media downloads (HTTPS-only, trusted Tencent domains, size limits, and header stripping) to prevent SSRF.

deeptutor/services/rag/pipelines/ima · high confidence

A new built-in parsing engine named 'text\_only' has been added to the system, providing a dependency-light path for extracting content from supported document formats (PDF, Office, EPUB, and text files). This engine leverages existing legacy text extractors to convert documents into markdown or plain text for downstream RAG providers, operating without the need for external model dependencies.

_deeptutor/services/parsing/engines/text\only · high confidence

Users can now engage in a dedicated chat conversation about a specific quiz question, its answer, and the AI's judgment. This feature introduces a new follow-up tab within the quiz viewer, featuring a chat composer that supports attachments, memory references, and LLM selection, while preserving the chat history across tab toggles and page reloads.

web/components/quiz · high confidence

The application now includes optional authentication capabilities, introducing a login page that accepts either an email or a username, and a registration page that allows new users to create accounts. The registration flow includes logic to detect and grant admin privileges to the first user, while the login page automatically redirects existing users to the home page and directs the first-time user to registration. These pages are styled with a consistent layout and support internationalization.

web/app/(auth) · high confidence

New client-side components (AdminLink, ProfileLink, LogoutButton) have been added to the sidebar. AdminLink displays a shield icon and links to /admin/users only when the user has admin privileges. ProfileLink shows the user's avatar and username, linking to /profile, and fetches auth status on mount. LogoutButton triggers the logout flow and redirects to /login. All components support collapsed/expanded states and use i18n for labels.

web/components/auth · high confidence

DeepTutor now supports connecting to a standalone, user-hosted LightRAG server for knowledge retrieval. This new provider offloads indexing and context retrieval to the external server, with DeepTutor acting purely as a client that fetches grounded context via the server's REST API. Users can configure a knowledge base to point to an external server URL and optional API key, with built-in health checks and authentication validation to ensure connectivity before use.

_deeptutor/services/rag/pipelines/lightrag\server · high confidence

A new \deeptutor\_web\ package has been introduced to manage standalone release assets for the web application. This package is designed to hold the output of a Next.js build (including \server.js\, static assets, and public files) for standalone deployments, while allowing source checkouts to fall back to the standard \web/\ directory structure.

_deeptutor\web · high confidence

DeepTutor now uses a dedicated plugin loader in the \deeptutor.plugins\ package to discover and instantiate capabilities. External packages can register under the \deeptutor.plugins\ entry-point group, and the system automatically discovers their manifests and loads \TurnCapability\ instances, providing a unified, domain-agnostic way to extend the tutor's functionality.

deeptutor/plugins · high confidence

The application now uses a dedicated setup service to manage initialization, including creating user directories and loading default settings for themes, logging, and LLM capabilities. This change consolidates port configuration and default agent parameters (such as token limits and temperatures) into a single entry point, ensuring consistent startup behavior and easier configuration management for users.

deeptutor/services/setup · high confidence

Courses are now full containers for learning material, replacing the previous dashboard-style view with a dedicated library and course pages. Users can now create and edit courses with specific settings, including a default conversation mode (Chat, Course Study, Guided Solving, or Quiz) and a default tutor persona. The interface introduces a 'Course Conventions' section where learners define subject-specific instructions and view tutor observations. A new 'Next Step' panel provides deterministic, evidence-based recommendations (e.g., focusing on weak question bank topics or continuing stalled mastery paths) to guide the learner. Progress is tracked via a 'Course Progress' dashboard showing mastery, question bank, reading, and notebook stats scoped to the course. Additionally, a 'Course Scope' system allows learning surfaces (like the question bank or reading workspace) to be opened within a course context, automatically attaching newly created resources to that course.

web/components/courses · high confidence

The API now provides a mechanism to deterministically export the backend's contract definitions for frontend consumption. New modules in the contracts package define the canonical v2.0 wire models for the turn protocol (including commands like start, subscribe, resume, and events) and expose them via a public API. An export script generates OpenAPI and turn-protocol JSON schemas into the web contracts directory, ensuring the frontend has access to the latest typed definitions and can detect schema drift.

deeptutor/api/contracts · high confidence

Added auto-generated TypeScript type definitions for the backend API (\api.ts\) and the real-time Turn Protocol (\turn-protocol.ts\). These files provide strict typing for API endpoints (such as agent configuration, authentication, and device management) and protocol messages (including client commands, server events, and state types), improving type safety and developer experience when interacting with the backend services.

web/contracts/generated · high confidence

The reading library now features a dedicated workspace where users can organize content into collections and manage a central material library. Users can upload files (PDFs, EPUBs, documents, audio, video) or add web links, with client-side duplicate detection to prevent redundant uploads. The interface provides two main views: a Collections tab for managing reading sets and a Material Library tab for browsing all uploaded assets, filtering by status (processing, failed, unassigned), and searching. The library integrates with course contexts, allowing course-specific collection views and material assignment.

web/components/reading/library · high confidence

Users can now engage in 'Immersive Watching' alongside YouTube videos, where the AI tutor grounds its responses in the video's transcript and current playback position. This capability provides timestamped context (e.g., \[MM:SS\]) to help the AI reference specific moments in the video, while explicitly treating the transcript as untrusted source material to prevent hallucination or unauthorized instruction following. The feature is accessible via the 'watching' or 'watch' CLI aliases and integrates with the standard agentic chat pipeline.

deeptutor/capabilities/watching · high confidence

The reading section now uses a dedicated workspace layout that provides Geogebra and quiz follow-up contexts, and introduces new routes for the reading library, materials library, and immersive reading sessions to support the new workspace-based reading experience.

web/app/(workspace)/reading · high confidence

This change adds the user-facing components for two new capabilities: a CLI Apps section for browsing and managing command-line tools available to the chat agent, and a comprehensive set of components for managing Model Context Protocol (MCP) servers. The CLI Apps interface allows users to view installed tools and browse a store, with administrative controls for installation. The MCP management suite includes a deployment-wide admin registry for configuring global servers, a per-user server list for managing individual connections, a catalog browser for discovering and installing MCP tools, and supporting UI elements for editing configurations, testing connections, and viewing server status.

web/components/cli-apps, web/components/mcp · high confidence

DeepTutor now supports installing and running third-party command-line tools through a sandboxed environment. Administrators can install apps from a vendored catalog (synced from CLI-Anything registries), which are executed safely via the sandbox runner with strict path and permission controls. The system exposes these installed apps as deferred tools to the chat agent, allowing the model to invoke them with argument vectors. This feature includes a secure installer that pins first-party harnesses to reviewed commits, handles per-app virtual environments, and enforces granular access controls so only granted and enabled apps are available to specific user accounts.

_deeptutor/services/cli\apps · high confidence

The new Co-Writer module enables users to import existing Microsoft Word (.docx) documents via a lazy-loaded converter that validates file integrity and enforces size limits, and provides a multi-document workspace backed by per-user file-system storage with atomic writes. An EditAgent allows users to rewrite, shorten, or expand text using reference context from RAG or web search, while NarratorAgent prompts support generating oral narration scripts and academic annotations in both English and Chinese.

_deeptutor/co\writer · high confidence

Users can now access the Co-Writer workspace to manage markdown drafts and projects. This update adds a home page that allows creating new drafts (with or without a starter template), importing existing Word documents (.docx), and deleting documents. The workspace includes a sample template demonstrating supported features like Markdown, code blocks, math, and diagrams.

web/app/(workspace)/co-writer · high confidence

This change adds two new chat-native capabilities to the platform. The Course Study mode acts as a course orchestrator that senses a learner's bound course state (syllabus, mastery, resources), recommends the next learning action, and hands the learner off to specific teaching surfaces like Immersive Reading or Mastery Path without teaching the material itself. The Partner authoring capability allows users to request a new educational companion profile via natural language, which the system converts into a reviewable draft for confirmation.

_deeptutor/capabilities/course\study · high confidence

The voice service now supports Aliyun DashScope for both text-to-speech and speech-to-text, adding native adapters alongside the existing OpenAI-compatible implementations. This change introduces a new adapter registry pattern in the voice service, allowing providers to be selected via configuration. It also includes a fix for speech-to-text uploads to strip MediaRecorder codec parameters from the content type, resolving 400 errors with OpenAI-compatible endpoints that reject codec-specific MIME types.

deeptutor/services/voice · high confidence

A new 'Deep Solve' capability has been added to the platform, enabling the chat agent to solve complex problems through a structured, multi-step loop. When activated, the agent is guided by a deterministic spine that requires it to first plan the solution steps via a \solve\_plan\ tool, execute each step using available tools (such as code execution or GeoGebra analysis), and mark steps as complete with \solve\_finish\_step\. The system enforces a bounded replan budget to handle course corrections, ensuring the agent does not skip steps or hallucinate solutions. This capability is available via the 'solve' CLI alias and integrates with the existing agentic chat pipeline, providing a rigorous, step-by-step reasoning process for users tackling difficult problems.

deeptutor/capabilities/solve · high confidence

DeepTutor now supports a GraphRAG-based retrieval pipeline as an optional feature (install via \pip install 'deeptutor\[graphrag\]'\). This new module bridges DeepTutor's existing document parsing and LLM/embedding configuration into the Microsoft GraphRAG engine, allowing users to build knowledge bases that index text into local knowledge graphs (entities, relationships, communities) for global, local, drift, and basic retrieval. The implementation includes a compatibility adapter to handle structured output requirements across different LLM providers, a configuration bridge to generate GraphRAG's \settings.yaml\ from DeepTutor's runtime config, and robust error handling for model incompatibility, embedding transport limits, and Pandas/Arrow extension issues.

deeptutor/services/rag/pipelines/graphrag · high confidence

This release adds a new Immersive Reading capability that lets users organize multiple materials (PDFs, EPUBs, web pages, YouTube, and Bilibili videos) into persistent workspaces with tabs and sessions. It introduces a source-grounded extension protocol that allows safe, server-side reading extensions (such as vocabulary, translation, quiz, and study guidance tools) to operate on verified text selections with bounded context windows. The engine also supports explicit bilingual EPUB pairing, durable W3C text selectors, and the export of annotated materials to PDF or Markdown.

deeptutor/reading · high confidence

A new snapshot subsystem has been added to the memory service to track changes in workspace content (such as notebooks, co-writer documents, books, and chat sessions) across refreshes. This feature introduces a three-layer memory architecture where the L1 layer maintains a persistent state of entity fingerprints and labels, allowing the system to detect added, modified, or removed items without reloading full content. Users benefit from a more efficient and accurate change log that records what has happened recently in their workspace, supporting features like 'what changed' views and optimized L2 memory updates by gating them on refresh timestamps.

deeptutor/services/memory/snapshot · high confidence

DeepTutor now includes a new LlamaIndex-backed retrieval pipeline that supports hybrid search (combining vector similarity and BM25 keyword matching) and optional cross-encoder reranking to improve result relevance. To prevent indexing stalls from blocking the server, document parsing and embedding are now executed off the main event loop, and a stall guard detects unresponsive embedding providers and fails fast with a clear error. The pipeline also handles large knowledge bases more efficiently by defaulting to a FAISS vector store (with opt-in HNSW for large corpora) instead of the previous slow brute-force scan, and it safely manages image extraction and multimodal indexing through the shared document-parsing engine.

deeptutor/services/rag/pipelines/llamaindex · high confidence

DeepTutor now supports connecting to external Model Context Protocol (MCP) servers, enabling agentic retrieval and tool use. This update adds a deployment-global server registry and a curated, offline-first catalog of installable services (e.g., Airtable, AWS Docs, Amap) that users can browse and install. It introduces secure credential handling where secrets are stored in owner-specific directories and resolved at connection time, preventing exposure in logs or configs. The integration includes robust network guards to prevent SSRF attacks by blocking private and link-local IP ranges for user-installed servers, and supports OAuth 2.1 for services requiring interactive authorization. Connection management is handled via a dedicated manager that supports lazy loading, reconnection on credential changes, and deferred tool schema loading to optimize chat performance.

deeptutor/services/mcp · high confidence

The \deeptutor/learning\ package is now available, providing the backend infrastructure for structured, mastery-based learning. This includes Pydantic data models for tracking learning progress, a deterministic grading system for short-answer and multiple-choice questions, and a recency-weighted mastery scoring policy. The engine also features a spaced-repetition scheduler, a migration tool to upgrade legacy V1 JSON/SQLite data to the new V2 store, and an event hub for real-time topic updates. Additionally, it provides navigation tools to display learning topics and module outlines to users.

deeptutor/learning · high confidence

Adds a new Math Animator capability that generates Manim-based math animations or storyboard images. The feature includes a full pipeline (concept analysis, design, code generation, rendering, and summary) with support for video and image output modes, configurable quality levels, and a retry loop that automatically repairs and re-renders code on failure. It also introduces a visual review step that extracts video frames for quality checks, enforces target duration parsing from user input, and ensures Windows compatibility for the Manim subprocess renderer.

_deeptutor/agents/math\animator · high confidence

A new MinerU parsing engine has been added to the document processing pipeline, enabling the system to parse Office files (DOCX, PPTX, XLSX) and images in addition to PDFs. The engine supports two execution modes: a local CLI mode that runs the MinerU tool on the host machine, and a cloud API mode that offloads processing to the MinerU service. The local mode includes a readiness gate to prevent silent, large-scale model downloads, requiring users to explicitly download models or enable auto-download in settings. It also includes a Windows-specific fix to serialize PDF rendering threads to prevent process crashes.

deeptutor/services/parsing/engines/mineru · high confidence

DeepTutor now supports PageIndex as a knowledge-base provider, available in both Cloud and Open-Source (OSS) modes. Users can ingest documents (PDFs for OSS; PDF, Markdown, Word, PowerPoint, Excel, and CSV for Cloud) into a PageIndex KB, which stores a lightweight manifest of document IDs rather than local embeddings. Retrieval is handled via an agentic loop that uses turn-scoped PageIndex SDK tools, allowing the model to read documents directly from the PageIndex service. The feature includes configuration for API keys (Cloud) and LLM bindings (OSS), validation to ensure only one OSS PageIndex KB is selected per request, and source attribution for retrieved content.

deeptutor/services/rag/pipelines/pageindex · high confidence

The new \deeptutor/partners\ package provides the infrastructure for instant-messaging integrations, including SSRF protection in \network.py\ that blocks requests to private and internal IP ranges, and \helpers.py\ which adds robust markdown table parsing (preserving empty cells and handling edge cases) and safe filename generation. It also introduces \transcription.py\ for voice-to-text processing via Groq's Whisper API and \split\_message\ logic to handle message length constraints safely.

deeptutor/partners · high confidence

Users can now engage with a new agentic chat mode that operates as a distinct capability within the tutor system. This change introduces a dedicated \AgenticChatPipeline\ and \ChatCapability\ in the \deeptutor/agents/chat\ module, which orchestrates an 'exploring' agent loop followed by a 'responding' stage to stream answers. The implementation leverages shared loop infrastructure (tool whitelists, excluded tools, and seed configurations) while exposing a specific CLI alias and request schema for chat interactions.

deeptutor/agents/chat · high confidence

The application now uses a dedicated configuration service layer in \deeptutor/services/config\ to manage user settings and capability tunables. This change introduces a unified system for reading and writing per-capability LLM parameters (such as temperature and max tokens) and runtime knobs (like research timeouts) from \agents.yaml\ and \main.yaml\, exposing them through a single API endpoint for the Settings UI. It also adds a model catalog service that securely manages provider credentials with secret masking, a knowledge base configuration service for managing RAG providers and search modes, and helpers for embedding endpoint resolution and context window detection. This centralization ensures that settings changes are consistently applied across the application and that sensitive data is protected during API interactions.

deeptutor/services/config · high confidence

Added a new chat-import library that enables users to import conversation histories directly from local \.claude\ and \.codex\ directories using the browser's File System Access API. The module detects the source type, scans for project or daily session groups, and parses the JSONL transcripts into a normalized format for upload. It includes an IndexedDB-backed agent registry to track imported sources and supports scoped re-syncing (by project or date) so users can keep their imported conversations updated without re-importing the entire folder.

web/lib/chat-import · high confidence

This change introduces a new, dedicated service layer for Partners in \deeptutor/services/partners\, replacing the previous TutorBot engine with a unified chat-agent loop. It enforces strict per-user data isolation by storing conversation history and memory in user-scoped directories rather than a shared admin pool, and adds a \/link\ slash command to bind anonymous IM senders to specific DeepTutor accounts. Additionally, it implements QR-based onboarding for Feishu/Lark and WeCom channels and migrates legacy shared channel state to the new per-partner structure.

deeptutor/services/partners · high confidence

The mastery capability now runs on its own agent loop instead of being a bolt-on to the chat pipeline, providing a dedicated tutoring experience with three distinct modes (outline, study, review) that gate specific tools. This change introduces a robust path-binding system that allows learners to switch between or leave mastery paths mid-conversation without losing progress, and enforces strict protocols for multiple-choice questions to ensure options are presented as interactive cards rather than plain text.

deeptutor/capabilities/mastery · high confidence

This change establishes a new \deeptutor/agents/research/utils\ package containing three core components: \json\_utils\ for robustly extracting and validating JSON from LLM outputs (including handling markdown fences and adjacent values), \citation\_manager\ for normalizing RAG source payloads and managing citation IDs across planning and research stages, and \token\_tracker\ for monitoring LLM token usage and costs using tiktoken with updated pricing for models like deepseek-v4-flash and deepseek-v4-pro. These utilities provide the foundational parsing, citation, and cost-tracking logic required by the research agent.

deeptutor/agents/research/utils · high confidence

The learning space now supports structured mastery goals where learners define a goal and select source materials, after which the tutor designs a study outline through conversation rather than a static editor. A new visual Learning Board displays modules as columns and knowledge points as cards with mastery status, while a Coverage Notice alerts learners if selected files were omitted from the generated outline and offers to regenerate it. Learners can switch between Outline, Study, and Review modes, edit the topic map via a Route Draft Editor, and receive celebratory feedback upon mastering knowledge points.

web/components/space/learning · high confidence

Users can now generate images via text prompts using the new image generation service. This adds support for Aliyun DashScope (via a dedicated async task adapter) and chat-completions-based image models (e.g., OpenRouter Flux/Gemini image), alongside the existing OpenAI-compatible path. The service resolves configuration from the existing model catalog (services.imagegen), allowing users to select providers and adjust generation parameters like size, quality, and style through the same Settings UI used for LLM/embedding/TTS.

deeptutor/services/imagegen · high confidence

This update adds two new agentic capabilities to the platform. The immersive reading capability allows users to open documents in a side panel and interact with them via chat; the assistant uses tools to outline, search, and read the full text of the open material, and can drive the reader to highlight specific passages or save annotations. Additionally, the Tencent IMA capability enables the assistant to interact with connected Tencent IMA knowledge bases, providing tools to list library contents, read full documents, search notes, and add URLs or write notes directly into the user's library.

deeptutor/capabilities/reading · high confidence

Adds a new immersive reading workspace that integrates video playback (YouTube and Bilibili) and audio materials directly into the reading interface. The workspace features a resizable chat companion panel that reuses the main chat's message list, composer, and session viewer, allowing users to ask questions about the material with grounded context (passage selection, viewport state). It includes a source navigator for outlines, transcripts, and chapters, along with bookmarking, conversation management, and notebook integration, providing a unified environment for reading and interacting with multimedia content.

web/components/reading/workspace · high confidence

This change adds a new 'Immersive Watching' experience to the web interface, centered around the new \WatchingWorkspace\, \WatchingPane\, \WatchingPlayer\, and \WatchingBrowser\ components. Users can now browse and play videos via YouTube or Invidious, with a synchronized transcript panel that highlights active cues and supports scrolling. The pane also enables timestamped note-taking, note export, and playback rate control. A new browser component allows users to connect Invidious accounts to browse feeds and playlists, with session state persistence and retry UX for unavailable captions.

web/components/watching · high confidence

DeepTutor now includes a dedicated authentication service for OpenAI Codex, enabling users to sign in via OAuth with PKCE and loopback callbacks. This change adds the \codex\_auth\ module, which manages credential storage, validates and caches the live model catalog from OpenAI, and exposes the available Codex models to the platform. The implementation ensures that authentication is scoped to the signed-in account and handles edge cases such as pasted callback addresses in Docker environments.

_deeptutor/services/codex\auth · high confidence

The Math Animator capability now uses a structured, multi-agent pipeline located in \deeptutor/agents/math\animator/agents\. This change introduces five distinct agent classes—ConceptAnalysisAgent, ConceptDesignAgent, CodeGeneratorAgent, SummaryAgent, and VisualReviewAgent—each handling a specific stage of the video generation workflow. The CodeGeneratorAgent includes robust retry logic to handle malformed LLM outputs, while the VisualReviewAgent adds a quality-check stage that intelligently skips when no review frames or vision-capable models are available. These components are exported via a new \\\init\\_.py\ module to facilitate clean imports.

_deeptutor/agents/math\animator/agents · high confidence

DeepTutor now includes a new RAG provider built on the native LightRAG SDK (pinned to version 1.5.7). This engine replaces the previous RAG-Anything implementation and introduces a graph-based retrieval approach with multiple query modes (naive, local, global, hybrid, and mix). The update adds a dedicated document ingestion pipeline that uses a versioned MinerU block policy to filter page-layout artifacts (like headers and footers) before indexing, ensuring only semantic content is processed. It also implements strict model pinning for indexing, allowing knowledge bases to lock specific LLM configurations to maintain index stability, and exposes concurrency and extraction settings for fine-tuning performance.

deeptutor/services/rag/pipelines/lightrag · high confidence

Users can now leverage new notebook agents to analyze selected records and generate concise summaries. The \NotebookAnalysisAgent\ performs a three-stage reasoning loop (thinking, acting, observing) to select relevant records and ground answers, while the \NotebookSummarizeAgent\ produces summaries for notebook entries. Both agents support bilingual prompts (English and Chinese) loaded from external YAML files and stream their output via LLM calls.

deeptutor/agents/notebook · high confidence

A new, engine-pluggable document-parsing service has been added to the backend, providing a unified interface for converting uploaded files into a canonical intermediate representation (markdown and optional structured blocks). The system now supports MinerU as a primary parsing engine, enabling richer content extraction, and includes a content-addressed cache to avoid redundant processing of identical files. Additionally, a fix ensures that relative image paths within parsed content are correctly resolved to absolute paths, preventing broken image references in downstream features like RAG indexing.

deeptutor/services/parsing · high confidence

A new 'explore-context' capability now runs a read-only pre-pass before the main answer loop whenever a chat turn includes attached textual sources (such as documents, notebook records, or conversation transcripts). This pre-pass actively investigates the sources using a dedicated agentic loop (or a fallback single-pass) to produce an objective, third-person briefing, which is then injected into the answer loop. This structural change prevents the model from confusing attached source content with the user's request and ensures weak models properly ingest source material, while also handling reasoning content correctly for thinking providers during replayed rounds.

_deeptutor/capabilities/explore\context · high confidence

The model selection service now supports runtime switching of the LLM model per conversation, allowing users to override the active model and reasoning effort without changing global settings. It also introduces a dedicated 'task' service configuration, enabling a separate, potentially faster or cheaper model to be used for background operations like conversation naming and starter generation, distinct from the model used for user-facing reasoning.

_deeptutor/services/model\selection · high confidence

The sandbox service now provides a pluggable execution environment that isolates code runs from the host system. It supports three backends: a runner sidecar for Docker deployments, bubblewrap for Linux bare-metal, and a restricted subprocess for local development, automatically selecting the strongest available isolation level. The service enforces per-user concurrency and rate quotas to prevent resource exhaustion, manages artifact exposure to ensure only safe output files are visible, and handles cross-platform compatibility including Windows execution support.

deeptutor/services/sandbox · high confidence

A new shared notebook service has been added to the backend, providing a unified storage layer for notebook data that is accessible by both the CLI and the Web interface. This change introduces the \NotebookManager\ class, which handles the creation, reading, and updating of notebook files stored under \data/user/workspace/notebook\, ensuring data consistency across different client types.

deeptutor/services/notebook · high confidence

This change introduces the backend infrastructure for the ClawHub skill hub, allowing users to discover, verify, and install skills from external registries. It adds a new \deeptutor.services.skill\ module containing a \SkillService\ for on-demand skill loading, a \hub.py\ provider for fetching and validating packages from hubs like ClawHub and EduHub, and a \credentials.py\ module to securely store publisher tokens with restricted file permissions. Additionally, a \taxonomy.py\ file is added to define the classification options (tracks, domains, stages) used when publishing skills.

deeptutor/services/skill · high confidence

The reading workspace now supports persistent, source-grounded annotations (highlights, underlines, notes, and citations) that remain anchored to the text even when the document reflows or the user zooms. A new annotation toolbar appears on text selection, allowing users to save marks and ask questions, while a dedicated list panel organizes these marks by location. Additionally, a new extension bar provides context-aware actions like reading aloud, vocabulary help, and translation directly within the reader.

web/components/reading · high confidence

Users can now run DeepTutor entirely from the command line via the new \deeptutor\ entry point, supporting both single-turn agent execution (\deeptutor run \<capability\>\) and an interactive multi-turn chat REPL (\deeptutor chat\). The CLI provides a comprehensive setup wizard (\deeptutor init\) for configuring LLM providers, embeddings, and search tools, along with dedicated commands for managing knowledge bases (\deeptutor kb\), sessions (\deeptutor session\), notebooks (\deeptutor notebook\), and system diagnostics (\deeptutor doctor\). Tool outputs in the REPL are intelligently truncated to reduce noise, with the ability to expand them on demand using the \/show\ command.

_deeptutor\cli · high confidence

The group chat surface has been replaced with a structured discussion interface that supports multiple conversation threads (sessions) per group, allowing users to keep separate topics distinct. Users can now select from different interaction modes—Parallel answers, Sequential (turn-based), and Cross-examination (debate)—which change how partners respond and how long the process takes. The new interface features a composer with @-mentions, inline quoting of previous answers, and a round-based layout where partners answer simultaneously or in sequence. It also includes peer-to-peer follow-up requests (invocations) that require user approval, a side panel to view private reasoning traces and shared context, and the ability to have a partner summarize a round's outcomes.

web/components/partners/group · high confidence

A new independent runtime engine has been added to compile user inputs (chat history, notebooks, knowledge bases, and intent) into structured, block-based, interactive "living books". This engine sits parallel to the existing ChatOrchestrator and provides a full lifecycle for book creation: ideation, spine planning, and asynchronous page compilation with streaming progress. It includes a dedicated compiler for block generation, a long-lived event hub for real-time updates, and a context module that allows selected book pages to be referenced directly within the chat interface. The engine also supports deterministic language inference, knowledge-base drift detection, and Markdown export.

deeptutor/book · high confidence

This change introduces the core agent loop implementation for the DeepTutor platform. The new subsystem includes the main loop orchestration logic (agent\_loop.py), the pipeline host that assembles turns with tools and budgets (pipeline.py), and structured prompt assembly (prompt\_blocks.py). It also adds support for DeepSeek's text-format tool calls (dsml\_tool\_calls.py) and live preview of 'ask\_user' tool arguments (ask\_user\_drafts.py), along with context window budgeting (context\_budget.py). This represents a foundational architectural shift in how agent turns are processed and streamed to users.

deeptutor/agents/loop · high confidence

The \deeptutor/agents/visualize\ module now provides a dedicated visualization capability that generates SVG, Chart.js, Mermaid, HTML, and Manim artifacts. The pipeline uses a structured analysis stage to determine the render type and visual genre, followed by code generation and a local validation step that checks output integrity (e.g., SVG well-formedness, Chart.js JSON structure) before final submission. This replaces the previous generic LLM review with deterministic, local checks to improve reliability and reduce unnecessary model calls.

deeptutor/agents/visualize · high confidence

The runtime bootstrap now includes a dedicated module that defines and registers all built-in capabilities (such as chat, problem solving, visualization, and immersive reading) using import-free descriptors. This change establishes a structured manifest for each capability, specifying its name, description, processing stages, available tools, and CLI aliases, which serves as the foundation for how these features are discovered and initialized within the application.

deeptutor/runtime/bootstrap · high confidence

The book generation engine now uses a structured registry of block generators (e.g., for code, quizzes, figures, and animations) instead of a monolithic approach. This change introduces a new \BlockContext\ that provides generators with chapter context, language settings, and optional RAG (Retrieval-Augmented Generation) lookups. Generators now use shared, robust LLM helpers that handle language directives, reasoning-effort retries, and JSON parsing, ensuring that generated content like code snippets and quiz questions are validated locally before being included in the book.

deeptutor/book/blocks · high confidence

The memory consolidator now supports a three-layer architecture (L1/L2/L3) driven by a workbench interface. Users can now perform chunk-based incremental updates, line-level auditing against raw evidence, and iterative deduplication on memory documents. The system uses character-based chunking with natural boundary expansion to preserve context, enforces objectivity via banned-phrase filters, and tracks changes through per-document metadata to identify new content since the last update. All operations are managed through persistent, cancellable runs with event streaming for real-time progress tracking.

deeptutor/services/memory/consolidator · high confidence

The \deeptutor/app\ module now provides a stable entry point for external adapters, exposing the \DeepTutorApp\ facade and \TurnApplicationService\ to handle turn lifecycle, session management, and capability resolution. This change centralizes the coordination logic, including turn recovery, lease management, and post-turn event streaming, ensuring that CLI, WebSocket, and SDK clients interact with a consistent backend interface. The \TurnApplicationService\ specifically manages the subscription to turn events, handling durable replay and lease-based stream termination to ensure clients receive all events, including post-turn metadata like session titles.

deeptutor/app · high confidence

The embedding service now uses a centralized adapter registry (\ADAPTER\BACKENDS\) in \deeptutor/services/embedding/adapters/\\init\\_.py\ to manage provider-specific implementations. This change introduces dedicated adapters for OpenAI (via both SDK and HTTP-compatible gateways), Cohere (v1 and v2 APIs), DashScope (text and multimodal), Gemini (native batch API), Jina (with task-aware embeddings and late chunking), and Ollama (local embeddings). A new \BaseEmbeddingAdapter\ abstract class and standardized \EmbeddingRequest\/\EmbeddingResponse\ dataclasses provide a unified interface, enabling consistent handling of features like variable dimensions, multimodal content, and SSL verification across all supported providers.

deeptutor/services/embedding/adapters · high confidence

The search service now uses a centralized provider registry in \deeptutor/services/search/providers\ that manages discovery, credential validation, and instantiation of search backends. This change adds support for 14 distinct providers—Aliyun IQS, Bocha, Brave, Doubao, DuckDuckGo, Firecrawl, Jina, Perplexity, Qianfan, SearXNG, Serper, Serply, Tavily, and Zhipu—allowing users to select their preferred search engine via configuration. The new architecture standardizes how search results and citations are returned across all providers and handles deprecated providers gracefully.

deeptutor/services/search/providers · high confidence

The \deeptutor/runtime/agentic\ package now provides a reusable, label-driven agentic engine that capabilities can compose for streaming, tool-using LLM interactions. This includes a client factory (\client.py\) that standardizes OpenAI/Azure connections, SSL handling, and key rotation; a label protocol parser (\labels.py\) that routes streaming responses by protocol tags (e.g., \THINK\, \TOOL\, \FINISH\); a single-step runner (\labeled\_step.py\) that handles reasoning content, inline thinking tags, and usage tracking; and an iteration scheduler (\loop.py\) that manages multi-turn loops, tool dispatch (\tool\_dispatch.py\), and protocol repair. This change centralizes the core agentic logic previously scattered across capabilities, enabling consistent streaming, tool calling, and reasoning handling across the platform.

deeptutor/runtime/agentic · high confidence

The runtime now supports multi-worker deployments through a new coordination layer that manages turn leases and background service ownership. This change adds a \RuntimeCoordinator\ protocol with implementations for both in-memory (single-process) and Redis (multi-worker) backends, enabling features like leader election for background tasks, turn recovery when workers are lost, and event journaling with batching. Users running with multiple backend workers must now configure a Redis URL, while single-worker setups continue to use the default memory backend without external dependencies.

deeptutor/runtime · high confidence

The \deeptutor/book/agents\ module now provides the core agents for the BookEngine pipeline, enabling users to generate structured books from a proposal. This includes the \IdeationAgent\ for creating initial book proposals, the \SourceExplorer\ for gathering evidence from knowledge bases, the \SpineSynthesizer\ for designing chapter structures and concept graphs, the \SpineAgent\ for legacy spine generation, and the \PagePlanner\ (renamed \SectionArchitect\) for planning detailed content blocks. These agents are now available for import from the \deeptutor.book.agents\ package.

deeptutor/book/agents · high confidence

The i18n module now provides localized descriptions for built-in capabilities (such as chat, deep\_solve, and deep\_research) and tools (such as brainstorm, exec, and web\_search) in both English and Chinese, allowing the settings UI and API to present accurate, language-aware copy. Additionally, a new StatusI18n helper enables capability pipelines to stream localized progress and error messages to the chat UI by loading per-feature status strings from YAML prompt files, ensuring that user-facing status updates respect the selected locale.

deeptutor/i18n · high confidence

Users can now explicitly select an 'Ask Questions' mode for a specific turn, which prompts the system to proactively ask 1–4 high-value, context-aware questions before proceeding. This capability, available via the 'ask' CLI alias, ensures the AI gathers missing information (such as goals, constraints, or preferences) from the full conversation history and memory, rather than guessing or skipping clarification. The feature includes localized system prompts for English and Chinese to guide the questioning behavior.

_deeptutor/capabilities/ask\questions · high confidence

The backend now exposes a dedicated set of API endpoints in the \\deeptutor/api/routers\\ package to support new and refactored product capabilities. A new partner channel schema introspection endpoint (\\GET /api/partners/channels/schema\\) allows the front-end to render generic configuration forms for any channel without hard-coding fields. Agent metadata (icons, colors, labels) is now served via \\/api/agents\\ to drive the UI. A persistent file library is introduced with endpoints for uploading, listing, searching, and downloading user-scoped files. Additionally, chat attachment previews are now served through a dedicated router that handles session-scoped access and MIME-type detection, while a new import endpoint allows users to bring in chat histories from external coding CLIs like Claude Code and Codex.

deeptutor/api/routers · high confidence

The API now includes several new utility modules in the \deeptutor/api/utils\ directory to support backend operations. \http\_headers.py\ provides a helper to correctly format Content-Disposition headers for non-ASCII filenames, ensuring compatibility with legacy clients. \task\_id\_manager.py\ introduces a singleton service to generate, track, and clean up unique IDs for background tasks, including metadata and status updates. \progress\_broadcaster.py\ manages WebSocket connections to broadcast real-time progress updates for knowledge base operations. \task\_log\_stream.py\ implements a streaming manager for emitting and subscribing to structured task logs and events via Server-Sent Events (SSE), with memory management for buffers and subscribers. Finally, \tool\_options.py\ adds a builder to construct the configurable tool surface, aggregating optional, built-in, and MCP tools with internationalized descriptions for the partners and multi-user admin APIs.

deeptutor/api/utils · high confidence

A new Agents Hub page has been introduced, featuring a 'Connected agents' section that allows users to discover, connect to, and consult live local agents (such as Claude Code, Codex, Gemini, and others) or remote Hermes gateways directly within the chat. This section also supports connecting user-defined 'partners' for real-time consultation, distinct from the imported-history agents that replay past transcripts. The UI includes brand-specific glyphs for each backend and handles connection states, loading indicators, and disconnection prompts.

web/components/agents · high confidence

Added a new Agents utility console consisting of a layout file and a page component. The layout provides a full-height flex container, while the page implements a scrollable hub with a max-width container and padding, mirroring the structure of other top-level consoles like memory. The page renders the AgentsHub component within this structured layout.

web/app/(utility)/agents · high confidence

The Books workspace has been restructured to support deep-linking directly to individual book pages (e.g., /books/\[bookId\]/pages/\[pageId\]) rather than defaulting to the library view, ensuring that direct links or refreshes open the correct content immediately. This update introduces a comprehensive set of UI components for the book lifecycle, including a \BookLibrary\ for browsing and searching, a \BookGenerationActivity\ strip that tracks real-time compilation progress without causing layout shifts, and a \BookHealthBanner\ that surfaces generation errors, quota issues, and knowledge base drift. It also adds a \BookChatPanel\ for interactive discussions, a \LearningCapturePanel\ for reviewing saved highlights, and a \BookSidebar\ for chapter navigation, providing a unified interface for creating, compiling, and reading AI-authored books.

web/app/(workspace)/books · high confidence

DeepTutor now includes two new document parsing engines: Docling and MarkItDown. The Docling engine supports both local and remote modes; local mode runs the Docling package in an isolated subprocess to avoid OpenMP conflicts with FAISS, downloads layout/table models on first run, and converts documents to Markdown. Remote mode sends files to a Docling Serve HTTP server via a REST API, supporting API key authentication and health checks. The MarkItDown engine provides a lightweight, pure-Python alternative that requires no model downloads and converts a wide range of formats (Office, PDF, HTML, images, etc.) to Markdown. Both engines are configurable via the Document Parsing settings, support version checking, and report readiness status.

deeptutor/services/parsing/engines/docling · high confidence

The Knowledge Center now features a comprehensive new UI for managing knowledge bases, replacing the previous workflow. Users can create new knowledge bases via a modal that supports multiple providers (including LightRAG, LlamaIndex, and Tencent IMA) and allows selection of specific indexing models and reasoning effort levels. The interface includes a dedicated file drop zone for uploading documents, a master-detail view for browsing and previewing KB files (PDFs, images, code, etc.), and tabs for managing external sources such as GitHub repositories and linked folders. This update also introduces folder-based organization within knowledge bases, allowing users to create, move, and delete files and folders directly from the UI.

web/components/knowledge · high confidence

A new MathAnimatorViewer component has been added to the web interface, providing a dedicated UI for rendering results from the math-animator service. Users can now view generated video outputs, browse image artifacts in a grid with a fullscreen preview option, and inspect the underlying Manim code in a collapsible section. The component also displays visual review warnings if the generated content has presentation issues, along with metadata such as quality scores, retry counts, and processing timings.

web/components/math-animator · high confidence

Users can now connect an Obsidian vault as a knowledge base, enabling the AI to directly read, search, and write Markdown notes within the vault using nine dedicated tools (such as obsidian\_search, obsidian\_read, obsidian\_create\_note, and obsidian\_append). The capability resolves the active vault from the selected knowledge base, injects the vault path securely server-side to prevent path traversal, and ensures that Obsidian vaults are excluded from the standard RAG index to avoid conflicts. It also handles encoding issues gracefully by tolerating undecodable bytes during reads while refusing to corrupt files during writes.

deeptutor/capabilities/obsidian · high confidence

This change introduces a new \partner\_group\ capability that enforces a public-answer protocol for collaborative sessions. It adds an \invoke\_other\ tool allowing a partner to propose a single, focused follow-up question to another peer, which is recorded as a pending user approval request rather than executed immediately. The system now strips peer-addressed requests from the public answer, saves a formal answer, and manages a one-time private decision round to prevent multiple hops or self-invocations, supporting both English and Chinese system prompts.

_deeptutor/capabilities/partner\group · high confidence

Users can now create and manage Partner Groups, which allow multiple AI partners to collaborate in a shared discussion session; this includes a new page to configure group details (name, members, discussion mode) and a dedicated group chat view. Additionally, the application layout now features a mobile-responsive design where the sidebar collapses into an overlay drawer on smaller screens, improving usability on phones and tablets.

web · high confidence

Added a new Partner detail page (\\[partnerId\]/page.tsx\) that serves as a chat-first interface for interacting with partners. The page features a tabbed layout allowing users to switch between Chat, Configure, Channels, and Archive views. It integrates with partner lifecycle management (start, stop, archive) and supports exporting conversation transcripts as Markdown. The implementation handles session persistence, manages access control for shared partners (restricting management tabs), and includes UI components for linking partners and saving conversations to a notebook.

web/app/(workspace)/partners/\[partnerId\] · high confidence

A new Partners page has been added to the workspace, providing a central list view for all AI companions (partners) and the groups they form. Users can now see a card for each partner, including their status (running/stopped), connected IM channels, and whether the partner is shared with them. The page also displays existing partner groups and allows users to create new partners or new groups directly from this interface, consolidating partner management and group convening into a single location.

web/app/(workspace)/partners · high confidence

A new document-parsing engine based on PyMuPDF4LLM is now available, allowing PDFs and e-books to be converted to Markdown while extracting embedded images and vector graphics into an images directory. This engine runs without CUDA or model downloads, making it suitable for low-end or GPU-less machines, and supports a wide range of formats including PDF, EPUB, MOBI, and various image types. Users can configure image output settings such as format (PNG, JPG, WebP) and resolution (DPI) through the document parsing settings.

deeptutor/services/parsing/engines/pymupdf4llm · high confidence

The Space section now includes dedicated pages for managing various utilities: a dashboard overview, chat history, CLI applications, MCP store, personas, question bank, and skills. Each page renders its corresponding section component, providing a structured entry point for these features within the Space layout.

web/app/(utility)/space · high confidence

Users can now generate and view visualizations directly in the chat interface. This new capability supports multiple render modes including Chart.js for data charts, inline SVGs with full light/dark theme support, Mermaid diagrams, and custom HTML content rendered in sandboxes. The feature includes a configuration panel to select render modes and manage visualizer extensions, and allows HTML visualizations to send prompts back to the chat composer via an iframe bridge.

web/components/visualize · high confidence

The web UI library now includes three new accessible components: a Button component that re-exports the shared implementation, a ConfirmDialog modal that replaces native browser prompts with a customizable, keyboard-accessible overlay (supporting danger tones, busy states, and i18n labels), and a Tooltip component that provides i18n-aware, focus-managed tooltips with configurable positioning. These components establish foundational design primitives for consistent, accessible interactions across the application.

web/components/ui · high confidence

The application now uses a unified set of components to display ongoing work across surfaces like chat, book compilation, and co-writing. This includes animated 'thought-orbs' (via the vendored \thinking-orbs\ library) to indicate active processing, and a standardized status dot system to show states such as running, completed, unread, or failed. A new activity detail grid and row layout provides a consistent two-level view for inspecting action specifics, replacing previous inconsistent spinners and glyphs with a cohesive visual language.

web/app/(utility)/avatar-preview, web/components/activity, web/vendor · high confidence

The admin section now includes a dedicated User Management page that allows administrators to view, search, and filter users. This interface supports creating new accounts with specific presets, deleting users, and promoting or demoting user roles (admin vs. standard). It also provides detailed editing capabilities for learner profiles, guardian relationships, and permissions via integrated editors, all protected by authentication checks that redirect non-admins away from the page.

web/app/(admin) · high confidence

This change introduces dedicated backend modules to manage user-specific settings that were previously handled elsewhere or not persisted. The new \interface\_settings\ module provides a robust, thread-safe mechanism for reading and writing UI preferences (theme, interface language, and response language) to \interface.json\, including logic to normalize language codes and migrate legacy single-language settings into separate interface and response language fields. Additionally, the new \starter\_settings\ module adds persistence for the 'trace count' configuration in \starters.json\, which controls how many recent activities the model considers when generating starter suggestions. These services ensure data integrity via atomic file writes and per-file locking.

deeptutor/services/settings · high confidence

DeepTutor now includes a built-in cron service that allows scheduling automated tasks for both chat sessions and partner conversations. Users can create jobs with one-shot, interval-based, or cron-expression schedules. When a scheduled job triggers, it automatically sends a reminder message: for chat sessions, the response is appended to the user's history, while for partner conversations, the prompt is injected into the partner's message bus and the reply is delivered via the original channel. The service uses a process-safe SQLite repository for persistence, including an automatic migration from legacy JSON storage, and supports local desktop notifications on macOS for interactive reminders.

deeptutor/services/cron · high confidence

The chat home surface now features a comprehensive composer toolbar that integrates multiple context selectors and capability controls. Users can now select connected subagents (such as Claude Code or Codex) via a dedicated AgentSelector, which also allows configuring a consultation budget (1–12 rounds) for the turn. The composer includes a ContextBudgetChip to visualize token usage across different context segments (messages, tools, memory, etc.) and a ContextReferenceTree to display attachments and references with expandable details. Additionally, the interface supports capability-specific configuration through CapabilityConfigCard, inline markdown notes via ChatMarkdownNoteTab, and interactive multi-question user prompts through AskUserOptions. The ComposerInput component has been optimized for performance, supporting @-mentions for agents, slash commands, and placeholder completions to streamline interaction.

web/components/chat/home · high confidence

A new page component has been added at the co-writer document route to serve as the entry point for the collaborative writing workspace. This component extracts the document ID from the URL parameters and passes it to the CoWriterWorkspace component, enabling users to access and edit specific documents within the co-writer feature.

web/app/(workspace)/co-writer/\[docId\] · high confidence

This change introduces the foundational infrastructure for running DeepTutor in containers, including a multi-stage Dockerfile, a hardened sandbox runner sidecar, and Podman-compatible compose files. It adds a \.dockerignore\ to optimize build contexts, a \.env.example\ for host-side port configuration, and a \CONTAINERIZATION.md\ guide. Additionally, it establishes a robust development workflow with \.pre-commit-config.yaml\ (enforcing Ruff, Prettier, and security checks), \.importlinter\ for architectural purity, and \.gitattributes\ to ensure cross-platform line-ending consistency.

(repo-wide) · high confidence

The web application now uses dedicated React context providers to manage state for the app shell (theme, language, sidebar, code block settings, active session), immersive reading (document material and annotations), immersive watching (video material and playback), quiz follow-up conversations, and GeoGebra interactive tabs. These providers centralize state management and persistence for these features, ensuring that state is preserved across navigation and that interactions like opening a GeoGebra tab or starting a quiz follow-up chat are coordinated through a consistent context-based API.

web/context · high confidence

The Learning Space now includes a comprehensive set of new components for managing conversation history, importing external data, and configuring agents. Users can view and restore archived conversations organized by surface (Chat, Mastery Path, Immersive Reading) via the new ArchivedConversations and ChatHistorySection components. A new ImportWizard and MyAgentsSection allow users to import chat history from local folders (e.g., Claude Code, Codex) and manage named, scoped agents. Additionally, the space now features a PersonasSection for creating and editing assistant personas, an EduHubImportModal for installing skills from the EduHub catalog, and an McpStoreSection for managing remote MCP server connections.

web/components/space · high confidence

The partners subsystem now uses an asynchronous message bus to decouple chat channels from the agent core, routing inbound messages through a queue and delivering responses via a separate outbound queue. A new plugin-based channel architecture introduces a BaseChannel interface and a ChannelManager that handles initialization, lifecycle management, and delivery flags. This change adds native support for DingTalk, Discord, Email, Feishu, Matrix, and Mattermost channels, each with specific configuration schemas and streaming capabilities.

deeptutor/partners/channels · high confidence

The repository now includes a suite of new scripts to improve development hygiene, deployment, and maintenance. \check\_architecture.py\ enforces strict dependency boundaries between core, application, and API layers to prevent architectural drift. \check\_branch\_policy.py\ and \check\_repo\hygiene.py\ protect the main branch from direct commits and prevent tracked generated files (like \.next\ or \\\pycache\\_\) from polluting the repository. For deployment, \docker\_compose.py\ simplifies container startup by rendering port mappings from JSON settings, while \install\_extras.py\ ensures optional dependencies are correctly installed in disposable Docker containers. Additional utilities include \prepare\_web\_package.py\ for bundling the Next.js frontend, \pb\_setup.py\ for bootstrapping PocketBase collections, and Windows-specific startup scripts (\start\_backend.bat\, \start\_frontend.bat\) to improve local development accessibility.

scripts · high confidence

The \deeptutor/utils\ package now includes a suite of new modules to handle document uploads and LLM response parsing. \archive\_extractor.py\ provides safe ZIP extraction with zip-bomb and path-traversal protections. \document\_extractor.py\ and \document\_validator.py\ enable text extraction from PDF, Office, and EPUB files, while \json\_parser.py\ introduces robust JSON parsing with markdown block extraction and reasoning-tag stripping. \secret\_files.py\ ensures secure file permissions for credentials, and \circuit\_breaker.py\ adds resilience for provider calls.

deeptutor/utils · high confidence

The Whisper page now includes dedicated React components for the dual-seat experience: WhisperComposer handles input and sending for both visitor and trainee roles with proper keyboard and IME handling; WhisperMessageList displays the conversation history with distinct visual styles for whisper, debrief, and system messages, including a step-by-step onboarding guide when the chat is empty; and WhisperRoomChip provides a copy-to-clipboard button for the room ID. All user-facing text in these components is now translatable via react-i18next.

web/components/whisper · high confidence

A new Whisper page has been added to the workspace, enabling a dual-seat interaction model where both 'visitor' and 'trainee' roles can participate in the same conversation room. The page uses the UnifiedTurnClient for real-time streaming and filters messages based on the active seat. It includes logic to detect and handle crisis scenarios, automatically closing the room and redirecting when specific crisis patterns are detected in the conversation. The interface is fully internationalized using react-i18next and integrates with the capability catalog for feature filtering.

web/app/(workspace)/whisper · high confidence

A new slide-in drawer component has been added to the chat interface, allowing users to preview attached files directly alongside their conversation without leaving the chat view. The drawer supports a wide range of file types—including PDFs, images, videos, SVGs, Markdown, code, text, and Office documents (DOCX, XLSX, PPTX)—using lazy-loaded renderers to maintain performance. For supported documents, users can now open files in the Immersive Reading workspace for a distraction-free experience. The implementation ensures smooth animations by deferring heavy content rendering until after the drawer slides in, and it handles various source types including public URLs and inline base64 data.

web/components/chat/preview · high confidence

A new \FollowupAgent\ has been introduced to handle single-call follow-up questions regarding individual quiz items. This agent allows learners to ask clarifying questions about a specific quiz question, providing context such as the question text, options, difficulty, learner's previous answer, and the correct explanation. It supports language directives and attachment handling, replacing the previous per-question/batch agent structure with a streamlined pipeline approach.

deeptutor/agents/question/agents · high confidence

Users can now preview a wide range of file types directly within the chat interface without downloading them. The new previewers include faithful DOCX rendering with page layout, XLSX spreadsheets with sheet tabs and row/column limits, PDFs via the browser's native viewer, and native playback for images, SVGs, and videos. Text-based files like Markdown and code are rendered with syntax highlighting, while Office files (DOCX, XLSX, PPTX) also support a plain-text extraction view. A fallback UI handles unsupported or legacy files with a download option. All previews use authenticated API calls and enforce size limits to prevent performance issues.

web/components/chat/preview/previewers · high confidence

The built-in tools module now includes a new kb\_files tool that allows the tutor to list documents in a knowledge base, check file counts, and filter by name—capabilities that retrieval alone cannot provide. Additionally, the RAG tool now includes provenance citations in its output, ensuring that claims are traceable to the specific chunks or entities retrieved, addressing previous issues where only the query was echoed back.

deeptutor/tools/builtin · high confidence

The web/lib area introduces a suite of new modules that power core user-facing capabilities. The i18n subsystem (I18nClientBridge, I18nProvider, init) provides SSR-safe, runtime language switching with lazy loading of locale bundles and accessibility lang-attribute sync. Auth is now resolved at runtime via /api/auth/status, supporting login, registration, logout, and caching, with admin user management (create, delete, role assignment) and learner profile management (read/write) exposed through dedicated API clients. Book capabilities are fully supported with a WebSocket-backed API for creation and spine confirmation, a pure reducer for live progress tracking, activity-state rendering for generation phases, and error translation for user-facing messages. Additional helpers include attachment limit enforcement, avatar parsing and fallback logic, backend API base resolution, and book reference normalization.

web/lib · high confidence

Added the \MasteryTopicPage\ component for the \/mastery/\[pathId\]\ route, which displays the learning path outline or visual learning board, manages topic selection, and handles progress actions like reset or delete. Also introduced dedicated routes for study sessions: \/mastery/\[pathId\]/sessions\ for starting new study conversations with configurable mode and course context, and \/mastery/\[pathId\]/sessions/\[sessionId\]\ for resuming existing sessions, both rendering the \MasteryStudy\ interface.

web/app/(utility)/mastery/\[pathId\] · high confidence

The memory utility section now includes a central hub page and dedicated routes for a three-layer memory subsystem (L1, L2, L3). Users can access the Memory Hub, view L1 workbench details with deep-link support for specific surfaces (chat, notebook, quiz, kb, book, partner, cowriter), and navigate to L2 and L3 workbenches for specific surfaces or slots (recent, profile, scope). A new resolver page handles citation lookups by ID, redirecting users to the appropriate memory layer and entry.

web/app/(utility)/memory · high confidence

DeepTutor now features a dedicated memory hub that organizes user data into three distinct layers: L1 (live workspace mirror across surfaces like chat and notebook), L2 (per-surface curated facts), and L3 (cross-surface knowledge synthesis). This update introduces a new MemoryHub dashboard, an L1 Workbench for browsing surface-specific snapshots, and a Workbench for editing L2/L3 documents with features like run controls for updating, auditing, and deduplicating memory. A new interactive Memory Graph visualizes relationships between entities, while a banner notifies users that their v1 memory has been archived and v2 starts fresh.

web/components/memory · high confidence

This change introduces a new multi-user feature area in the web frontend, providing administrators with dedicated UI components and API clients to manage learner access and configuration. The \LearnerProfileEditor\ allows admins to set learner-specific attributes such as age, grade level, curriculum, and explanation style. The \GrantEditor\ enables the configuration of user grants, including LLM models, knowledge bases, skills, partner assignments, and tool permissions (including MCP tools and execution policies). Additionally, the \BookPermissionEditor\ lets admins manage shared book access, allowing them to control whether learners can create personal books, set default access levels for new shared books, and assign specific read or edit permissions for individual admin books. The \GuardianRelationshipsEditor\ facilitates the management of guardian relationships, including assigning permissions like managing materials or resetting credentials. These components are backed by new API functions in \api.ts\ and type definitions in \types.ts\ that define the structure for grants, learning policies, and book permissions.

web/features/multi-user · high confidence

This release adds the Next.js page components that serve as entry points for the Knowledge Bases, Notebooks, and Chat features. The Knowledge Bases route now wraps the KnowledgePage component in a Suspense boundary to handle loading states. The Notebooks console is exposed via new routes that resolve course scope from URL parameters and pass it to the NotebookConsole, ensuring the view stays pure while supporting course-specific filtering. The Chat workspace is now accessible via dedicated page routes for both the general chat view and specific session views, importing the ChatWorkspace component directly.

web/app/(utility)/knowledge-bases, web/app/(utility)/notebooks, web/app/(workspace)/chat · high confidence

This change introduces a suite of new React components for the Partners workspace, enabling richer partner customization and channel management. Users can now select and assign knowledge bases, skills, and notebooks to partners via the AssetPicker, and customize partner identities with the FaceEditor (supporting emoji, colors, and image uploads). The PartnerChannels panel provides a schema-driven interface for configuring communication channels, including QR-based onboarding for platforms like WeChat and WeCom, and displays real-time connection status. Additionally, the PartnerArchives component allows users to view, resume, and delete past partner conversations.

web/components/partners · high confidence

A new five-step wizard (Identity, Soul, Mind, Library, Review) is now available for creating partners. Users can configure the partner's name, description, visual identity (face/avatar), language, personality source (soul), and select specific LLM models with optional backups. The wizard also allows enabling specific tools (including MCP tools) and attaching assets like knowledge bases and skills before submitting the creation request.

web/app/(workspace)/partners/new · high confidence

The persona service now ships with three pre-configured behavior presets—Peer, Teacher, and Research Assistant—seeded into the admin workspace on first run. These presets define specific interaction styles (e.g., Socratic questioning for Teacher, collaborative exploration for Peer, rigorous citation-focused analysis for Research Assistant) that are injected into the system prompt to shape the AI's voice from the start. This change also includes a migration path that moves legacy persona-type entries from the skills workspace into the new personas structure for existing users.

deeptutor/services/persona · high confidence

The document parsing system has been refactored into a pluggable engine architecture, introducing a central registry that allows users to select from multiple parsing backends including MinerU, Docling, MarkItDown, PyMuPDF4LLM, LiteParse, and the newly added remote Apache Tika engine. This change introduces a new settings interface where users can one-click install optional parser packages and download required model weights directly from the UI without using the command line. The new Tika engine specifically enables parsing via a remote Apache Tika 4 server, supporting over a thousand file types through content-based detection and returning Markdown output, with configuration managed via a server URL setting.

deeptutor/services/parsing/engines · high confidence

DeepTutor now includes a new visualizer package in \deeptutor/visualizers\ that enables the chat agent to generate and submit interactive visualizations. The system defines a declarative protocol (manifests, payloads, and envelopes) and provides a registry to manage core, bundled, and user-installed visualizer types. A new chat-loop capability (\VisualizationLoopCapability\) guides the agent to select an appropriate visualizer type, generate a validated payload, and commit it via the \submit\_visualization\ tool. Built-in validators ensure payloads meet specific format requirements (e.g., SVG accessibility, Chart.js structure, GeoGebra constraints) before rendering.

deeptutor/visualizers · high confidence

A new question generation system has been introduced in the \deeptutor/tools/question\ module. This includes a backward-compatible entry point (\mimic\_exam\_questions\) that delegates to a new \AgentCoordinator\ for orchestration, and a \question\_extractor\ that utilizes MinerU-parsed content (markdown and content lists) to extract exam questions via LLM. The extractor supports various question types (choice, concept, fill-in-blank, etc.) and handles nested MinerU output directories, while re-exporting shared MinerU parsing utilities for public API compatibility.

deeptutor/tools/question · high confidence

The chat interface now includes dedicated selection modals (pickers) for attaching various content types to conversations. Users can now reference specific books and reading materials, select from a question bank, choose behavior personas, attach memory artifacts (summaries and profiles), and reference imported agent conversations or partner sessions. These new components—BookReferencePicker, ReadingReferencePicker, QuestionBankPicker, PersonaPicker, MemoryPicker, and MyAgentsPicker—integrate with the existing ChatSpaceMenu to provide a unified way to ground chat requests in structured external data.

web/components/chat · high confidence

Added \ResearchConfigPanel\ and \ResearchOutlineEditor\ components to the web interface. The config panel allows users to select research modes (Study Notes, Report, Comparison, Learning Path) and depths (Quick, Standard, Deep, Manual), with manual mode exposing sliders for sub-topics and iterations. The outline editor enables users to review, edit, add, and remove sub-topics before confirming the research plan, providing visual status indicators for editing, researching, complete, and failed states.

web/components/research · high confidence

The web interface now exposes a dedicated runtime status feature. Users can view the health of the turn runtime (Healthy, Degraded, Recovering, Unavailable) via the RuntimeHealthCard, which displays key metrics such as worker count, coordination mode (In-process or Redis), leader health, and recovery backlog. Additionally, a new TurnCoordinationSettings component allows operators to configure backend worker counts (1–32), select the coordination backend, and set advanced parameters like lease TTL and recovery intervals, with validation ensuring Redis is configured when multiple workers are enabled. The feature fetches data from the /api/system/runtime endpoint and includes safeguards to prevent exposure of credential-like fields in the status payload.

web/features/runtime-status · high confidence

A new dedicated HTTP service (the sandbox runner) has been introduced to handle untrusted shell commands. This sidecar runs in its own least-privileged container, ensuring that the main application never executes shell commands directly. It exposes a specific API (POST /exec) for submitting commands with resource limits (timeout, memory, CPU) and validates work directories to prevent path traversal, thereby improving security and isolation for user-run code.

deeptutor/services/sandbox/runner · high confidence

DeepTutor now includes a new 'setup' capability that allows the assistant to inspect and modify its own configuration directly within the chat interface. This feature introduces four new tools: \inspect\_setup\ to view current settings and identify missing components (like embedding models or parsing engines), \apply\_setting\ to change configuration values with pre-write validation and connection testing, \request\_credential\ to securely handle API keys by redirecting to the settings page, and \run\_setup\_job\ to install engines or download model weights with live progress streaming. The capability enforces strict access controls, allowing personal settings changes for all users while restricting global deployment settings to administrators, and explicitly blocks configuration changes initiated by partner bots to prevent unauthorized reconfiguration of owner accounts.

deeptutor/capabilities/setup · high confidence

This release introduces a centralized API client in \web/shared/api\ that standardizes HTTP requests, normalizes error responses (including explicit retryable flags), and handles authentication redirects. A new typed storage layer (\web/shared/storage\) provides versioned, validated, and migratable local/session storage with cross-tab synchronization. Additionally, a suite of accessible, reusable UI primitives (Button, Dialog, Field, Tooltip, etc.) is now available in \web/shared/ui\ to ensure consistent styling and behavior across the application.

web/shared · high confidence

The \web/components/common\ directory now includes a suite of new shared components that standardize and enhance the user interface. Assistant responses are rendered via \AssistantResponse\, which supports smooth streaming, model thinking blocks, and citation linking. Content rendering is handled by \MarkdownRenderer\ and \InlineMarkdown\, which intelligently switch between lightweight and rich modes for math, code, and HTML. Interactive elements like \GeogebraOpenCTA\ and \BrandIcon\ provide specialized visualizations and branding. Picker interfaces (\PickerShell\, \PickerHeader\) now feature consistent accessibility, focus trapping, and animation. Additional utilities include \Modal\ for dialogs, \McpToolGroups\ for tool selection, \InlineFileCard\ for file attachments, \ProcessLogs\ for terminal output, and \ProviderIcon\ for vendor logos.

web/components/common · high confidence

This release introduces a comprehensive logging and event system for DeepTutor. The new \deeptutor.logging\ package provides a unified, structured logging pipeline that outputs JSONL to files and human-readable text to the console, supporting request-scoped context (such as task and session IDs) and LLM usage cost tracking. It also includes a bridge for Loguru and an adapter to forward LlamaIndex logs into the main system. Additionally, a new asynchronous event bus (\deeptutor.events\) is added to handle inter-module communication with non-blocking publish/subscribe capabilities for events like task completion.

deeptutor/logging · high confidence

Users can now select a connected local AI agent (such as Claude Code, Codex, or partner backends) as a knowledge base, which routes the chat turn exclusively to a new \consult\_subagent\ tool. This allows the chat model to delegate tasks like code inspection or script execution to the live agent, with the agent's step-by-step execution streamed in real-time to the sidebar. The implementation ensures this subagent connection coexists with standard RAG knowledge bases by excluding subagent references from the RAG index, preventing conflicts when both are selected.

deeptutor/capabilities/subagent · high confidence

DeepTutor now includes a new subagent service that lets you connect local AI coding assistants—such as Claude Code, Codex, Antigravity CLI, DeepSeek Harness, Hermes Agent, Kimi CLI, opencode, MiMo Code, and OpenClaw—as interactive subagents. The new \deeptutor/services/subagent\ package provides a unified backend interface, per-backend configuration (model, effort, permissions, sandbox, image forwarding), and a consult budget to control turn depth. It streams native events (text, tools, reasoning, errors) into the chat sidebar, supports session resumption for continuity, and adds a remote Hermes Agent gateway backend for connected agents. This is the core wiring for the subagent capability; other areas handle the chat loop, UI, and API integration.

deeptutor/services/subagent · high confidence

The \deeptutor/tools\ package introduces a new tool registry and a suite of capabilities for the tutor agent. The \ask\_user\ tool enables the tutor to pause the conversation and present structured, multi-option questions to the user, with support for live previews as the model generates arguments. A new \exec\ tool allows the agent to run Python, C, C++, or shell code in a sandboxed environment with platform-specific command handling and strict security deny-lists. The \knowledge\_frontier\ tool uses the existing knowledge base to derive research queries and search arXiv for recent papers. Additionally, the package includes a \brainstorm\ tool for idea generation, a \cron\ tool for scheduling background tasks, and a \github\_query\ tool for read-only access to GitHub PRs, issues, and workflows.

deeptutor/tools · high confidence

DeepTutor introduces a dedicated \deeptutor.services\ package that centralizes core capabilities including LLM clients, embedding, RAG, prompt management, and web search behind a lazy-loading interface to reduce startup overhead. The package also adds an optional authentication system (disabled by default) that supports single-user password login, multi-user registration with admin roles, and optional PocketBase integration for session storage. Additionally, it provides an app update service for managing PyPI and source-checkout upgrades, a CodeBuddy authentication coordinator for IDE plugin session reuse, and a base class for background source-sync services.

deeptutor/services · high confidence

A new profile page has been added, allowing users to view their profile information and customize their avatar. Users can now select from a set of icons with various colors or upload a personal image, which is automatically cropped to a square and optimized for web use. The page also includes functionality to remove uploaded images and sign out of the account.

web/app/(utility)/profile · high confidence

The \deeptutor/tools/vision\ package has been introduced to handle image processing and GeoGebra script integration. It includes a block parser that extracts and validates GeoGebra scripts from LLM output, automatically fixing common syntax errors such as incorrect bracket usage or unsupported comment styles. The module also provides coordinate transformation utilities to map bounding box pixel coordinates to GeoGebra's mathematical coordinate system, and image utilities for fetching and converting images from URLs to base64 format.

deeptutor/tools/vision · high confidence

The sidebar now features a redesigned session list with inline renaming, unread indicators, and localized grouping, alongside a new user avatar component that supports custom icons, colors, and admin badges. For content visualization, the application introduces a GeoGebra component for interactive math graphs and a Mermaid component for rendering diagrams that dynamically adapts to light, dark, glass, and snow themes. To prevent flash-of-wrong-theme on load, a server-side ThemeScript component now initializes the theme from localStorage before React hydration.

web/components · high confidence

The application now includes a 'Watching' page that renders the chat workspace in a dedicated watching mode. Additionally, a new theme system has been introduced with four distinct visual palettes: 'Cream' (warm off-white with terracotta accents), 'Dark' (warm near-black with terracotta accents), 'Snow' (pure white neutral with blue accents), and 'Glass' (translucent purple panels on a dark background with blur effects). These themes are defined via CSS custom properties in the global styles and are supported by updated layout and font configurations.

web/app · high confidence

The web build and development workflow now relies on a new set of Node.js scripts in \web/scripts\. These scripts manage the build lifecycle (\build.mjs\, \dev.mjs\), generate typed backend contracts (\generate-contracts.mjs\), and handle specific asset requirements like copying PDF.js WebAssembly assets (\copy-pdfjs-assets.mjs\) and brand icons (\build-brand-icons.mjs\). Additionally, new tooling is introduced for developer productivity and quality assurance, including an i18n audit and parity checker (\i18n\_audit.mjs\, \i18n\_parity.mjs\), a route size budget checker (\route\_budgets.mjs\), and isolated TypeScript type-checking (\typecheck.mjs\).

web/scripts · high confidence

A new web-source sync subsystem has been added to crawl documentation sites (such as Docusaurus, MkDocs, GitBook, and ReadTheDocs) and ingest their content into knowledge bases. The system includes an async crawler that extracts readable text and internal links, an HTML-to-markdown extractor that strips navigation chrome and boilerplate, and logic to safely localize snapshot images. It also features a sync pipeline that compares page hashes, writes new or changed pages as Markdown files, removes deleted pages, and rebuilds the search index, while enforcing security bounds like SSRF host validation and path containment to prevent directory traversal.

_deeptutor/services/web\source · high confidence

DeepTutor now includes an optional multi-user layer that enables per-user workspaces, role-based access control (admin vs. user), and explicit guardian-to-learner authorization. Users can sign in to their own accounts, with admin-curated books and knowledge bases shared selectively via grants. Guardian relationships allow designated users to manage restrictions, assign materials, view reports, and reset credentials for learners. The system also supports revocable device credentials for local learner accounts, server-enforced learning policies (e.g., age bands, locked personas, allowed capabilities), and audit logging for resource access and admin actions. PocketBase mode is currently single-user only due to schema limitations.

_deeptutor/multi\user · high confidence

Users can now upload files that are permanently saved to local disk, enabling attachments to persist across chat sessions and allowing files to be stored in a shared library for reuse in future conversations. The system deduplicates files by content hash to save space, supports soft-deletion for library items, and ensures safe file handling with path validation and atomic writes.

deeptutor/services/storage · high confidence

The Question Bank interface has been completely rebuilt to allow learners to organize quiz questions into custom categories. You can now create, rename, and delete categories, and file questions into them directly from the bank view or via a floating selection bar when multi-selecting items. The new interface includes a scope rail to filter by status (All, Wrong, Needs Review, Bookmarked, Unfiled) and categories, a toolbar with search and sorting, and a dedicated category manager panel.

web/components/space/question-bank · high confidence

The sidebar has been restructured to support a customizable, drag-and-drop navigation layout where users can reorder and fold workspace features (such as Co-Writer, Book, Mastery Path, and Immersive Reading) into a 'More' menu. Session history rows now display precise status indicators (live, unread, failed, or idle) using a refined SVG mark system, and a new Recycle Bin section allows users to restore or permanently delete archived chats. The sidebar also includes a version badge that checks for app updates and a collapsed icon-only rail that preserves access to all features.

web/components/sidebar · high confidence

The RAG service has been refactored into a unified entry point that supports multiple retrieval backends, including LlamaIndex (default), PageIndex, PageIndex OSS, GraphRAG, LightRAG, LightRAG Server, Tencent IMA, and WeKnora. This change introduces a factory-based pipeline selection system, allowing knowledge bases to be bound to specific providers. It also adds support for linked knowledge bases, enabling users to mount existing external index folders (for LlamaIndex, GraphRAG, and LightRAG) without re-indexing, with automatic embedding compatibility checks. Additionally, the service now includes a file type router for handling various document formats (PDF, EPUB, Office, etc.) and preflight checks to verify engine availability and configuration.

deeptutor/services/rag · high confidence

The notebook experience has been restructured around a new \NotebookConsole\ that serves as the central hub for creating, renaming, and deleting notebooks, with automatic scoping when accessed from within a course. A new \SaveToNotebookModal\ now allows users to save chat results directly to a notebook and, for chat sessions, selectively include specific messages in the saved record. Additionally, a new \NotebookRecordPicker\ enables users to select and ground requests with records from multiple notebooks simultaneously, while \NotebookRecordActions\ provides a unified menu to edit, delete, or move/copy records between notebooks.

web/components/notebook · high confidence

The session service now uses a unified repository-backed architecture that supports both local SQLite storage and an optional PocketBase integration. Users can now store and retrieve chat sessions using a standardized protocol, with automatic fallback to SQLite if PocketBase is not configured. The system includes legacy migration tools to import existing JSON chat sessions, context builders for managing conversation history with token budgets, and support for artifact attachments and ask\_user clarifications. Session organization features include soft delete with recycle bin functionality, parent-child session relationships, and integrity validation to prevent cycles.

deeptutor/services/session · high confidence

Users can now connect their own Invidious instances to DeepTutor for video playback and transcript access, with a secure authorization flow that stores tokens in owner-private secrets. The video learning module also introduces persistent, timestamped notes linked to specific points in the video, which can be exported as Markdown. This change adds the core backend services, account management, and note persistence for the video learning domain.

_deeptutor/video\learning · high confidence

The LLM service layer has been refactored into a new provider core module that centralizes provider implementations and uses lazy loading to avoid importing heavy SDKs until a provider is actually used. This change introduces first-party provider classes for Anthropic (Claude), Azure OpenAI (Responses API), OpenAI Codex (OAuth), GitHub Copilot, and CodeBuddy (HTTP and Agent SDK), along with a generic OpenAI-compatible provider for other endpoints. The new base classes and response models standardize how chat, streaming, tool calls, and reasoning content are handled across all providers, improving stability and reducing startup overhead.

_deeptutor/services/llm/provider\core · high confidence

The deeptutor/core package now provides the foundational interfaces and data structures that power the agent runtime. This includes the Capability Protocol (TurnCapability, CapabilityManifest) for defining multi-step deep modes, the Tool Protocol (BaseTool, ToolDefinition, ToolParameter) for standardizing built-in and plugin tools, and a UnifiedContext dataclass that aggregates session state, attachments, and configuration for every turn. Additionally, a unified StreamEvent system enables consistent progress streaming to clients, while a robust entry-point loader ensures plugins load safely without crashing the application, and a typed TurnRequest model handles input validation with backward-compatible migration of legacy runtime config keys.

deeptutor/core · high confidence

The LLM service has been refactored into a unified module that centralizes provider configuration, capability detection, and error handling. Users benefit from a consistent interface for all LLM providers (cloud and local) with automatic retry and exponential backoff. The new system includes a centralized capabilities registry that accurately reflects each provider's support for features like vision, streaming, tool calling, and response formats, replacing scattered hardcoded checks. Additionally, the service now provides a unified exception hierarchy for better error handling and mapping provider-specific errors to consistent internal exceptions.

deeptutor/services/llm · high confidence

The session turn handling has been restructured into a composable runtime located in \deeptutor/services/session/turns\. This new architecture introduces distinct components: \TurnExecutor\ manages the core generation loop and streaming events, \TurnLifecycle\ handles process-level coordination, update blocking, and turn ownership, \TurnRequestPreparer\ validates and routes incoming requests, \TurnContextAssembler\ builds conversation context, \LearningTurnAdapter\ manages mastery path leases and card grading, and \SessionTitleService\ automatically generates session titles. This modularization replaces the previous monolithic turn handling, improving separation of concerns for execution, state management, and learning-specific logic.

deeptutor/services/session/turns · high confidence

The prompt service now uses a unified PromptManager to load, cache, and retrieve prompt configurations from YAML files, replacing scattered loading logic across modules. This change introduces robust multi-language support with a defined fallback chain (e.g., zh -\> en) and a new language directive system that allows users to override the default output language during conversations, fixing the previous issue where non-English languages were incorrectly collapsed to Chinese.

deeptutor/services/prompt · high confidence

The chat workspace has been refactored to use a new v2 turn runtime and a centralized capability catalog. A new \capabilities\ feature provides a typed model, API client, and React hook to fetch and filter available capabilities (such as Chat, Solve, Quiz, and Research) from the backend, replacing the previous static configuration. The chat state and transport are now managed by a new \ChatRuntimeProvider\ and \ChatStateAdapter\, which handle turn lifecycle, message branching, and streaming via the v2 protocol. This change introduces a \ProtocolMismatchNotice\ to alert users when the client and server versions diverge, and updates the message list and trace presentation to align with the new turn model.

web/features/chat · high confidence

The Co-writer workspace component has been restructured to improve maintainability and separation of concerns. The monolithic component logic is now distributed into dedicated React hooks: \useDocumentLifecycle\ handles document request cancellation and stale-result gating, \useSelectionEdit\ manages abort controllers for selection-based edits, \useSplitPane\ controls the editor/preview panel resizing and layout preferences, and \useSynchronizedScroll\ manages the synced scrolling state between editor and preview. Additionally, the \editor-state\ module now explicitly defines the undo/redo history structure and selection replacement logic, while the \storage/drafts\ module handles local storage persistence with a versioned draft format (v2) and migration from legacy keys. This refactoring ensures that the workspace component focuses on presentation while business logic for editing, layout, and persistence is encapsulated in reusable, testable units.

web/features/co-writer · high confidence

The Courses section has been restructured from being a sub-surface within the Learning Space to an independent top-level area. This change introduces a dedicated layout and index page at the \/courses\ route, where the index now renders the course shelf directly without a redundant heading, and the course detail page owns its own navigation shell and back-link logic rather than relying on the previous space container.

web/app/(utility)/courses · high confidence

The Deep Research feature has been completely rewritten to use the new agentic engine, replacing the previous multi-agent implementation. This change introduces a structured four-phase workflow: rephrasing the user's topic via an interactive mini-loop, decomposing the topic into sub-topics (with an optional outline preview for user confirmation), executing parallel research blocks using a dynamic topic queue, and generating a final report with inline citations. The new implementation supports four distinct modes (notes, report, comparison, learning path) with configurable depth levels, and integrates read-only Obsidian tools for knowledge base retrieval while enforcing tool timeouts and retry policies for resilience.

deeptutor/agents/research · high confidence

DeepTutor v1.6.8 adds a new content workspace service that isolates model-authored programs and artifacts in a private \.deeptutor\ directory, ensuring user data remains owned by the path service while providing a stable, sandboxed execution environment with local caches for Python, npm, and other tools. The release also establishes a CLI entry point via \python -m deeptutor\ and centralizes version management in \\_\version\\_.py\, while updating LLM retry defaults (max retries to 8, base delay to 5.0s) and deprecating the legacy \llm\_retry\ settings property in favor of the new \retry\ configuration.

deeptutor · high confidence

The web client now strictly validates turn protocol interactions against version 2.0 boundaries. Command builders in \turn-command.ts\ enforce non-empty IDs, non-negative sequence numbers, and required fields (e.g., text or answers for replies), while \turn-event.ts\ parses incoming server events by verifying protocol version, event types, and field structures, rejecting invalid or unsupported frames with diagnostic details. This ensures that malformed commands are caught before transmission and that the client reliably handles or reports protocol errors from the server.

web/contracts/parse · high confidence

The backend API entry point has been replaced with a new FastAPI application (deeptutor/api/main.py) that initializes the application container, validates tool consistency, and manages startup migrations. To resolve Windows subprocess issues, the server startup script (run\_server.py) now explicitly sets the WindowsProactorEventLoopPolicy. Additionally, CORS settings have been updated to support remote Docker/LAN origins in local/single-user mode while requiring explicit configuration when authentication is enabled, and access logging is disabled by default to reduce noise.

deeptutor/api · high confidence

The visualize capability now uses a three-stage agent workflow to produce SVG, Chart.js, Mermaid, or HTML visualizations. An AnalysisAgent determines the render type and creates a structured brief, a CodeGeneratorAgent produces the corresponding code using format-specific rules, and a ReviewAgent performs targeted repairs when local validation fails. This replaces the previous single-step approach with a more robust, staged process that includes defensive parsing and error-driven re-generation.

deeptutor/agents/visualize/agents · high confidence

The runtime now uses a new registry layer in \deeptutor/runtime/registry\ that lazily loads capabilities and tools on first access, improving startup performance. It introduces a \DeferredToolLoader\ that keeps external tool schemas out of the initial system prompt, reducing context size and improving tool selection for weaker models; tools are loaded on-demand via a \load\_tools\ call. Additionally, a \ScopedToolRegistry\ enforces per-turn authorization for provider tools using an allowlist, preventing unauthorized tool execution and resolving name collisions between multi-tenant overlays and shared tools.

deeptutor/runtime/registry · high confidence

The knowledge base domain has been refactored from a monolithic structure into a dedicated \\deeptutor.knowledge\\ package with lazy-loaded exports. This change introduces a formal \\KnowledgeBaseManager\\ for centralizing operations, a \\KnowledgeBaseInitializer\\ for creating new bases, and a \\DocumentAdder\\ for incremental updates. It also adds a \\kb\_types\\ module to distinguish between standard indexed bases and various connected types (such as Obsidian, MarginNote 4, and external servers), and a \\manifest\\ module to provide accurate document inventories. Additionally, progress tracking is now translatable via i18n-ready message keys, and name validation is enforced to prevent filesystem conflicts.

deeptutor/knowledge · high confidence

The knowledge feature's API layer has been restructured into modular client files (catalog, engines, files, sources) that expose specific functions and types for managing knowledge bases and retrieval engines. This change introduces detailed configuration controls for the LightRAG indexing model, including settings for concurrent file parsing, LLM call limits, and entity extraction passes, alongside provenance labeling support. The EngineDetail component now provides in-place UI forms for configuring these engine-specific parameters (such as GraphRAG community levels and LightRAG retrieval modes) and handles model selection for LLM and embedding services, allowing users to fine-tune how documents are indexed and retrieved.

web/features/knowledge · high confidence

The Mastery Path feature has been moved from the Learning Space hub to its own dedicated route, giving it a full-height shell and independent navigation. Users now enter Mastery as a primary destination rather than a nested section, which removes the previous stacked 'back to Learning Space' affordances; each screen within the path now manages its own back links (e.g., study to topic, topic to atlas). The page also supports course-scoped views, allowing users to narrow the topic atlas to specific courses and seamlessly create new topics that launch directly into an outline session.

web/app/(utility)/mastery · high confidence

The memory consolidator now exposes four user-visible modes—Update, Audit, Dedup, and Merge—replacing the previous monolithic implementation. The Update mode uses chunk-based incremental fact extraction to handle large inputs more reliably, while Audit mode performs line-level edits against raw evidence. Dedup mode iteratively merges or deletes duplicate entries, and Merge mode consolidates footnote references without using an LLM. Legacy public API shims (consolidate\_l2, consolidate\_l3) are maintained for backward compatibility, ensuring existing integrations continue to work while the underlying implementation switches to this new modular architecture.

deeptutor/services/memory/consolidator/modes · high confidence

The web application introduces a suite of new React hooks in the \web/hooks\ directory to centralize and improve client-side logic. \useChatAutoScroll\ replaces the previous multi-path scrolling implementation with a single \useLayoutEffect\ and \MutationObserver\ system to eliminate stuttering during LLM streaming and handle late-mounting content viewers. \useAuthStatus\ shifts authentication state resolution to runtime by fetching from the backend, allowing the frontend bundle to remain agnostic of auth configuration across different deployment environments. \useKnowledgeBases\ and \useKnowledgeProgress\ consolidate knowledge base lifecycle management, including polling, WebSocket subscriptions, and history tracking, while \useKnowledgeHistory\ persists task logs to local storage. Additional hooks include \useCardSubmission\ for handling question card answer submissions with retry logic, \useLingerExpand\ for smoother toolbar menu interactions, \useOutsideClick\ for consistent dropdown closing, \useCollapsiblePanel\ for persisted sidebar states, \useConnectedAgentKinds\ for caching subagent metadata, \useContextBudget\ for reading context window usage, \useDevice\ for responsive layout branching, \useDragSort\ for pointer-driven sidebar reordering, \useImaConnection\ for managing IMA knowledge base credentials, and \useLLMOptions\ for loading the model catalog with single-flight deduplication.

web/hooks · high confidence

The chat engine now uses a new loop-capability architecture that allows features like Mastery, Solve, and Ask Questions to run as modular extensions, while also introducing new capabilities such as MarginNote 4 support and immersive watching. Crucially, this change fixes a conflict where enabling RAG alongside an exclusive knowledge capability (like Obsidian) would previously block RAG access; the new system now allows RAG to coexist with exclusive capabilities, ensuring users can still leverage their standard knowledge bases even when using specialized knowledge tools.

deeptutor/capabilities · high confidence

The runtime now includes a dedicated provider layer that manages external tool access and safety. This introduces an explicit allowlist system to handle unrestricted versus restricted tool access, per-kind authorization functions (starting with MCP tools) to enforce policy based on user grants and ownership, and text sanitization to prevent prompt injection from third-party tool descriptions. A new view component assembles the final tool surface for each turn, ensuring that only authorized tools are visible and that the system degrades gracefully if external providers are unavailable.

deeptutor/runtime/providers · high confidence

The question-generation capability has been refactored to use the new agentic engine, replacing the legacy \\AgentCoordinator\\ with a structured \\QuestionPipeline\\. This new pipeline operates in three phases: an Explore phase that uses agentic loops to research topics and review quiz history, a Plan phase that emits a JSON plan of question templates, and a Quiz phase that generates individual questions with schema validation and repair. The system now supports a 'mimic' mode that parses uploaded exam papers (via MinerU) into templates to generate questions that preserve the source paper's format and difficulty. A compatibility adapter preserves the \\AgentCoordinator\\ interface for legacy WebSocket routes, and lazy imports in the package entry point prevent eager loading of heavy LLM dependencies.

deeptutor/agents/question · high confidence

The previous two-file MemoryService has been removed and replaced by a new three-layer memory architecture. Raw events are now captured as append-only JSONL traces (L1), which are consolidated into per-surface markdown summaries (L2) and cross-surface synthesis documents (L3). The system introduces a new \MemoryStore\ facade for all interactions, ULID-based identifiers for stable entry tracking, and a pure-function document parser that supports both new ref-keyed and legacy entry-keyed markdown formats to ensure backward compatibility. A new \recall\ module allows the system to query recent learner activity across surfaces using only timestamps, and user-tunable consolidation settings are now managed via a dedicated configuration subsystem.

deeptutor/services/memory · high confidence

The Settings interface has been refactored from a multi-route structure into a single-page layout where users can scroll through all configuration sections—from Overview to About—while a persistent side navigator allows direct jumping to specific anchors. This change introduces a new layout component that wraps the settings area with multiple context providers (including access control, UI state, and model catalog) and implements dynamic, lazy-loaded sections for Appearance, Network, Workspace, Models, Knowledge, Chat, Agents, Learner Profile, Guardian, Memory, and About. The new structure ensures that protected deep links wait for authentication resolution before mounting, preventing premature API calls, and consolidates the settings experience into one cohesive document.

web/app/(utility)/settings · high confidence

The Settings interface has been rebuilt to improve organization and usability. A new CategoryScroll component provides a persistent, searchable navigation that allows users to jump directly to specific sections. A new Connections Editor centralizes credential management, enabling users to create shared API keys that automatically link to multiple services (LLM, Task, Embedding, etc.) to reduce repetitive configuration. Model configuration is now presented via expandable Provider Cards, and a new Memory Usage Item displays live system memory consumption for the backend and frontend processes. Additionally, new components like CodexOAuthCard and CodeBuddyAuthCard streamline provider-specific authentication flows.

web/components/settings · high confidence

The Settings page has been reorganized into feature-owned sections with a new navigation system that respects user roles. Admin-only, learner-only, and guardian-only settings are now hidden or shown based on the user's account type, and the page now scrolls correctly within its own pane without affecting the rest of the application.

web/features/settings · high confidence

The vision solver now uses a single vision model call to generate GeoGebra commands from math problem images, replacing the previous multi-stage pipeline. A gated repair pass automatically retries only if the initial analysis fails to produce valid commands, reducing latency and improving reliability for the geogebra\_analysis tool used in chat and solve modes.

_deeptutor/agents/vision\solver · high confidence

This change introduces a shared utilities module for the DeepTutor agent pipelines. It centralizes the logic for composing enabled tools based on user toggles and context flags (such as knowledge bases or notebooks), ensuring consistent tool availability across chat and quiz capabilities. It also adds robust helpers for extracting JSON from model outputs (handling reasoning blocks and fenced code) and standardizes the emission of capability results, ensuring that cost summaries and metadata are consistently attached to every response.

_deeptutor/agents/\shared · high confidence

The prompting module now loads per-tool metadata from YAML files and renders them into structured prompt fragments. Users benefit from clearer, context-aware tool suggestions in the chat interface, including bilingual support (English and Chinese), phased organization of tools (Exploration, Expansion, Synthesis, Verification), and detailed usage instructions (when to use, input format) to help the system decide which tool to invoke.

deeptutor/tools/prompting · high confidence

The agents module now provides a unified BaseAgent class that standardizes LLM configuration, prompt loading, and token tracking across all agent types (research, question, chat). This change consolidates previously scattered agent implementations into a single inheritance hierarchy, ensuring consistent behavior for model selection, parameter handling, and logging regardless of the specific agent module being used.

deeptutor/agents · high confidence

DeepTutor now uses a centralized embedding service that standardizes how text vectors are generated across all modules. This change introduces a unified client that automatically clamps batch sizes to respect individual provider limits (such as SiliconFlow's 32-item cap) and enforces a global rate-limiting mechanism to prevent blocking the event loop during concurrent indexing tasks. It also adds strict validation for embedding responses to catch invalid or inconsistent vector dimensions early, and supports a tri-state toggle for sending dimension parameters to ensure compatibility with providers like Jina that require specific Matryoshka dimension handling.

deeptutor/services/embedding · high confidence

The web search capability has been completely rebuilt to support a pluggable provider architecture (including new providers like Serply) and improved answer formatting. Search results are now automatically consolidated into readable answers using provider-specific Jinja2 templates or optional LLM synthesis. Additionally, a new reference safety filter is applied to all results, blocking unsafe content (such as adult or gambling material) and enforcing domain trust policies to ensure only educational or trusted sources are surfaced.

deeptutor/services/search · high confidence

The workspace area now wraps its UI in ChatRuntimeProvider, ReadingProvider, and WatchingProvider, ensuring that chat sessions, reading state, and watching state persist across navigations (such as moving from /chat to /chat/\<id\>) and are accessible throughout the workspace. A new utility layout provides similar structure for utility routes, and the workspace root redirects to /chat.

web/app/(workspace) · high confidence

The PDF.js WebAssembly assets in web/public/pdfjs/wasm now include explicit license files for third-party components (LICENSE\_JBIG2, LICENSE\_OPENJPEG, LICENSE\_QCMS) and their respective PDF.js wrappers (LICENSE\_PDFJS\_JBIG2, LICENSE\_PDFJS\_OPENJPEG, LICENSE\_PDFJS\_QCMS). This ensures proper attribution and compliance with the Apache 2.0 and BSD licenses for the JBIG2 and OpenJPEG decoding libraries used in PDF rendering.

web/public/pdfjs · high confidence

This change introduces a core compatibility layer for the OpenAI Responses API to fix several defects that prevented features from working correctly. It corrects tool choice mapping so that forced tool selections (like 'ask\_user') are no longer rejected by the API, and aliases 'max\_completion\_tokens' to 'max\_output\_tokens' to prevent request errors on newer models. Additionally, it hardens the parsing of streaming responses to correctly handle server-side web search results, persist reasoning context across turns for providers like DeepSeek, and properly propagate stream failures instead of silently dropping them.

_deeptutor/services/llm/provider\_core/openai\responses · high confidence

Users who do not have an LLM model assigned to their account will no longer see or access LLM-powered features; instead, they will see a locked notice explaining that they need administrator assistance. This is implemented via a new access context that checks for available LLM options and a route-level gate that blocks direct URL access to gated pages, ensuring the UI reflects backend enforcement.

web/components/access · high confidence

5 commits adding/updating tests in tests/agents; Add CI model catalog and LightRAG parser-bridge test fixtures; Added API regression tests for auth, book, and co-writer features; Added comprehensive CLI test suite; Added comprehensive test coverage for MCP service reliability and security; Added comprehensive test coverage for the Book module; Added comprehensive test coverage for the DeepTutor learning engine; Added comprehensive test coverage for the chat agent pipeline; Added comprehensive test coverage for the memory subsystem; Added comprehensive test coverage for the video learning feature; Added comprehensive test coverage for tools and parsing engines; Added comprehensive test suite for multi-user account management and access controls; Added comprehensive test suite for the Immersive Reading domain; Added comprehensive tests for search provider configuration and web search runtime behavior; Added core test suite for agentic runtime, capabilities, and tooling; Added regression tests for LLM provider fixes and capability overrides; Added regression tests for the vision solver agent; Added runtime test coverage for launcher, orchestration, and memory management; Added test coverage for RAG pipeline components; Added test coverage for deployment and utility scripts; Added test coverage for services module; Added test coverage for session service components; Added test coverage for skill service, hub, and CLI login flows; Added test coverage for the CLI apps service; Added test coverage for the cron service and repository; Added test coverage for the document parsing service; Added test coverage for utility modules; Added tests for Codex authentication and model catalog services; Added tests for GeoGebra command validation and visualizer registry; Added tests for LLM model selection and reasoning effort handling; Added tests for LLM probe token budget configuration; Added tests for MarginNote 4 capability integration; Added tests for NotebookSummarizeAgent extra\_headers handling; Added tests for PersonaService CRUD, migration, and seeding; Added tests for ReadSkillTool error handling and file listing limits; Added tests for agentic loop reasoning replay, tool argument validation, and streaming tool-call accumulation; Added tests for capabilities subsystem; Added tests for config service reliability and correctness; Added tests for image generation modality fallback logic; Added tests for knowledge base document handling and manager operations; Added tests for language directive override logic; Added tests for markdown table parsing edge cases in partner channels; Added tests for runtime coordination and architecture boundaries; Added tests for runtime provider authorization and tool view logic; Added tests for sandbox execution security and backend configuration; Added tests for the Math Animator agent components; Added tests for the Persistent File Library; Added tests for the logging subsystem and task log streaming; Added tests for the plugin entry-point loader; Added tests for turn reclamation and multiworker coordination; Added tests for visualize agent reliability and error handling; Added tests for web source snapshot processing; Added unit tests for the Deep Research pipeline internals; Added unit tests for the Question agent pipeline and language handling; Expanded test coverage for embedding service adapters and client runtime; Expanded test coverage for partner services and channel infrastructure; Expanded test coverage for tool registry, dependency metadata, and release workflows; Expanded test coverage for web application core features.

This change introduces the primary dependency manifests for the DeepTutor project. The Python side defines \pyproject.toml\ for the main \deeptutor\ package and \packaging/deeptutor-cli/pyproject.toml\ for the CLI-only distribution, establishing a Python 3.11–3.14 runtime requirement and including core libraries for LLM integration (OpenAI, Anthropic, LlamaIndex), RAG retrieval (FAISS, BM25), document processing (PyMuPDF, pdfplumber), and server infrastructure (FastAPI, PocketBase). The web side initializes \web/package.json\ and \web/package-lock.json\ for the \opentutor-web\ frontend, locking in Next.js 16, React 19, and associated UI and testing dependencies.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 50.

• Code Health 62
• Architecture 69
• Maturity 80
• Readiness 44
• Security 52
• Accessibility 52

• 300 commits — 170 feature/other, 130 fixes

• (repo) — 78 commits
• deeptutor/services — 41 commits
• web/components — 23 commits
• web/features — 15 commits
• web/locales — 14 commits
• web/tests — 10 commits
• deeptutor/agents — 9 commits
• tests/services — 9 commits
• web/lib — 9 commits
• deeptutor/multi_user — 8 commits
• deeptutor/api — 7 commits
• deeptutor/runtime — 7 commits
• deeptutor/video_learning — 5 commits
• assets/README — 4 commits
• deeptutor/capabilities — 4 commits
• deeptutor/skills — 4 commits
• (root) — 3 commits
• deeptutor/book — 3 commits
• deeptutor/tools — 3 commits
• web/contracts — 3 commits

• fix: Merge branch 'dev' into codex/fix/ask-user-turn-state
• fix: Merge branch 'dev' into codex/fix/chat-pdf-tool-hallucination
• fix: Merge branch 'dev' into fix/web-route-budgets
• fix: Merge pull request #1145 from KryptonGao/fix/settings-i18n
• fix: Merge pull request #1146 from ZQR1101/fix/video-learning-windows-fcntl
• fix: Merge pull request #1151 from evan188199-tech/codex/fix/sandbox-exec-limits
• fix: Merge pull request #1231 from evan188199-tech/codex/fix/learner-courses-1228
• fix: Merge pull request #1258 from wangyuxy9805-web/fix/1245-question-notebook-image-upsert
• fix: Merge pull request #1261 from AmirF194/fix/1259-partner-connected-kb-provisioning
• fix: Merge pull request #1266 from evan188199-tech/codex/fix/chat-pdf-tool-hallucination
• fix: Merge pull request #1271 from georgelichen/fix/responses-input-status-compatibility
• fix: Merge pull request #1274 from ZQR1101/fix/web-route-budgets
• fix: Merge pull request #1276 from Iams4kura/bugfix/markdown-atx-heading-normalization-20260906t160231z
• fix: Merge pull request #1278 from evan188199-tech/codex/fix/ask-user-turn-state
• fix: Merge remote-tracking branch 'origin/dev' into fix/1259-partner-connected-kb-provisioning
• fix: Merge remote-tracking branch 'origin/dev' into fix/responses-input-status-compatibility
• fix: Revert "feat: add remote Hermes connected agent backend (#1208)" (#1212)
• fix: fix(agent-loop): recover bounded reasoning-only finishes (#1402)
• fix: fix(agentic): distinguish empty vs missing tool args (#1101)
• fix: fix(agents): ignore leading think blocks when extracting JSON (#1388)
• …and 280 more

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

HKUDS/DeepTutor 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.