THU-MAIC/OpenMAIC

OpenMAIC is an AI-powered classroom platform that enables educators to author, generate, and deliver interactive, multi-agent learning experiences. It provides a comprehensive workbench for managing course documents, scenes, and folders, alongside a Pro-mode editor for designing slide-based content with integrated AI assistance. The system supports immersive Project-Based Learning (PBL) through specialized instructor, evaluator, and simulator agents, while handling media generation, transcription, and video export to create self-contained, offline-capable educational materials.

The playback engine now supports jumping to specific speech actions within a scene, allowing users to skip or revisit content without replaying the entire sequence. This feature includes intelligent safety checks that prevent jumping past actions that would break the playback state (such as video plays or widget interactions) and handles whiteboard actions appropriately. Additionally, the system now persists the user's playback position across sessions using a new device-scoped cursor, migrating legacy state from the previous storage mechanism. A new auto-resume capability ensures that interrupted lectures automatically continue after Q&A or discussion sessions end, improving the continuity of the learning experience.

lib/playback · high confidence

Users can now parse documents using two new cloud-based providers: MinerU Cloud (via the MinerU v4 API) and AliDocMind (Aliyun Document Mind). The \lib/pdf\ module introduces dedicated client implementations (\mineru-cloud.ts\, \alidocmind-client.ts\) and a shared result parser (\mineru-parser.ts\) to handle these services. The provider registry (\constants.ts\) and type definitions (\types.ts\) have been updated to include these new options, which require API keys. Additionally, the existing \unpdf\ provider now supports a \textOnly\ mode to skip image extraction, and the \parsePDF\ function accepts optional file metadata (filename, MIME type) to better support the new providers.

lib/pdf · high confidence

Introduces the initial infrastructure for document-based retrieval in the RAG system, including document chunking logic that splits text by grapheme clusters and HTML block boundaries, an ingestion pipeline that transforms document artifacts into knowledge chunks with lineage tracking, and an in-memory lexical index that supports token-based querying, metadata filtering, and scoped retrieval by workspace and course.

lib/rag · high confidence

A new API route at /api/generate-classroom/\[jobId\] has been added, allowing users to poll the status of a classroom generation job. The endpoint validates the job ID, retrieves the current job details (including status, progress, and result) from the job store, and returns structured success or error responses. It also includes a poll URL and interval for client-side polling logic.

app/api/generate-classroom/\[jobId\] · high confidence

The @openmaic/importer package now includes the source code for the original 'pptxtojson' parser (in src1/) and new CLI scripts for debugging and testing. The src1/ directory contains the complete implementation for parsing PPTX files, including modules for handling alignment, animations, borders, charts, colors, fills, fonts, mathematical formulas, and positioning. Two new scripts have been added: extract-pptx-structure.js, which displays and optionally extracts the internal file structure of a PPTX file, and transvert.js/transvert.ts, which allow direct testing of the original parser and the new parser respectively by converting a PPTX file to JSON output.

packages/@openmaic/importer/scripts, packages/@openmaic/importer/src1 · high confidence

The classroom export feature has been significantly enhanced to produce fully self-contained, offline-capable ZIP files. Interactive HTML content is now inlined with all external assets (CSS, JavaScript modules, images, and audio) converted to data URIs, ensuring the exported classroom works without an internet connection. The export manifest has been updated to version 1, introducing a structured media index and robust handling of agent voice configurations (including TTS voice cloning data) with validation to prevent malformed data from breaking imports. Additionally, users can now download the classroom's narration script as either a Markdown file or a formatted DOCX document for lesson preparation.

lib/export · high confidence

Users can now organize courses into folders within the discovery view. This update introduces a folder card that displays stacked course covers and supports drag-and-drop filing, a dialog for creating new folders with name validation, and a menu to move courses into existing folders or create new ones on the fly.

components/discovery · high confidence

The action engine in lib/action now supports whiteboard history tracking and auto-save, allowing users to undo/redo whiteboard changes. It also introduces support for code elements on the whiteboard, rendering them as structured line items. Additionally, the engine now facilitates communication with widget iframes via a new callback mechanism, enabling richer interactive experiences. Math content on the whiteboard is now rendered using KaTeX for improved visual fidelity. The engine's constructor and execute method have been updated to accept new options and callbacks, reflecting these expanded capabilities.

lib/action · high confidence

OpenMAIC is now available as an AI-powered classroom platform that generates immersive, multi-agent interactive lessons. The release includes a comprehensive environment configuration template (.env.example) supporting a wide range of LLM, TTS, ASR, and media providers, alongside a Dockerfile for containerized deployment. The project is licensed under MIT and provides documentation for contributing and using the platform.

(repo-wide) · high confidence

Introduces the \@openmaic/importer\ package, which provides an import pipeline to convert \.pptx\ files into OpenMAIC canvas \Slide\[\]\ structures. The package exposes \importPptx()\ and \parsedToSlides()\ APIs that parse PPTX content (including text, shapes, images, tables, charts, and math) and optionally upload media assets to a remote storage via a provided \OssUpload\ callback. The package includes a browser-focused build (UMD, ESM, CJS) configured via Rollup, TypeScript strict compilation, ESLint rules, and Vitest test configuration.

packages/@openmaic/importer · high confidence

The platform introduces an Interactive Mode that allows the AI to observe and reference live DOM elements within courseware scenes. This is enabled by new \lib/interactive\ modules that handle browser-side observation, logical viewport fitting, and element reference policies, alongside new \ElementReference\ types in \chat.ts\ for identifying slide elements or interactive components. Additionally, the system now supports a broader set of interactive widgets, defined in \types/widgets.ts\, including simulation, diagram, code, game, 3D visualization, and procedural skill widgets. The update also expands LLM provider support to include Azure, Bedrock, Grok, and Ollama, and introduces granular 'thinking' configuration controls for reasoning models.

lib/types · high confidence

The new @openmaic/dsl package establishes the central, pure-spec contract for the MAIC SDK family, containing the slide object model, lesson skeleton, and playback verb definitions with zero runtime dependencies. It provides a unified set of TypeScript types, pure structural validators, and element normalizers that repair documents by filling required defaults and deriving geometry, ensuring consistency across producers. The package also introduces a versioned migration registry to handle serialized document shape changes, a standardized asset manifest enumerator for export pipelines, and cross-language JSON Schema artifacts generated at build time for non-TypeScript consumers.

packages/@openmaic/dsl · high confidence

The \@openmaic/editor\ package is now available, providing a controlled editing surface for slides built on top of \@openmaic/renderer\ and \@openmaic/dsl\. It exposes a core transaction system for undo/redo history and a React-based UI layer (\EditableSlideCanvasWithUI\) that handles element selection, dragging, resizing, rotation, and text editing. The package includes built-in toolbars, alignment guides, and snapping logic, while allowing host applications to manage document state and provide custom capabilities like localization and asset picking.

packages/@openmaic/editor · high confidence

The repository now includes the \@openmaic/renderer\ package, extracted from the main OpenMAIC codebase to provide a self-contained, read-only slide rendering component for any React + Tailwind 4 application. This package exposes a \SlideCanvas\ component that accepts slide data via props, supporting optional playback effects (laser, spotlight, highlight, zoom) and media injection slots for images and videos. It also provides a \SlideRendererProvider\ for context-based data sharing, granular element components (e.g., \BaseTextElement\), and TypeScript types. The package is configured for ESM-only distribution via Rollup, requires Tailwind 4, and includes self-hosted font support for six CJK families (SourceHanSans, SourceHanSerif, LXGWWenKai, ZhuQueFangSong, WenDingPLKaiTi, ZcoolHappy) served from a CDN, along with full license attribution and build/test configurations.

packages/@openmaic/renderer · high confidence

This change introduces a new set of API routes under /api/agent that power the Agent Workbench. These endpoints enable session management (creation, listing, cancellation, and status tracking), durable event streaming via Server-Sent Events (SSE) with replay capabilities, and the posting of follow-up messages. It also adds support for user-defined skills (listing, uploading, and deleting) and integrates automatic conversation title generation upon message submission.

app/api/agent · high confidence

This change adds five new server-side API routes under /api/pbl/v2 to power the v2 Project-Based Learning runtime. The /evaluate endpoint handles task, milestone, and final evaluations via a unified SSE stream. The /instructor route streams instructor-led turns, while /open-task triggers the instructor's initial greeting or setup phase, including pre-play quiz recalibration. The /simulator route provides in-character roleplay turns for scenario projects. Finally, /task/update provides state-mutation actions for the workspace UI, allowing learners to start microtasks, complete pending tasks, continue after handovers, and enter or complete scenario acts without LLM involvement.

app/api/pbl/v2 · high confidence

The PBL v2 scene renderer now includes a complete set of new UI components for the learner workspace and evaluation flow. This adds a multi-agent tabbed interface (AgentTabs) that currently supports the Instructor and is extensible for future roles, alongside a dedicated chat panel (Chat) that handles live streaming, multi-line input, and external stream integration. The update introduces a suite of evaluation cards: MilestoneCard for stage reflections and handovers, TaskEvaluationCard for inline task feedback, and a CompletionCtaCard that prompts learners to view the final report. A new Completion page (Completion) displays a detailed final report combining LLM narrative with deterministic engagement stats. Supporting utilities include a pure logic handler for applying instructor SSE events (apply-instructor-event), a fit-to-container scaling helper (fit-scale) for the Hero page, and a StarRating component for visual feedback.

components/scene-renderers/pbl/v2 · high confidence

This change adds the server-side entry points for the Pi in-class multi-agent chain. The new POST /api/chat/pi route handles the main agent loop, supporting features gated by feature flags such as the native child runtime, scoped spotlight, and whiteboard tools, while also validating courseware references and agent configurations. Additionally, a new POST /api/chat/pi/whiteboard-visibility route allows clients to settle whiteboard visibility states (open/closed) for specific queries and stages, requiring persistence authentication.

app/api/chat/pi · high confidence

The storage layer now includes a new PostgreSQL implementation for agent sessions, providing durable persistence for session metadata, event logs, and entry trees. This backend introduces specific database tables (agent\_sessions, agent\_session\_events, etc.) with constraints for status and title state, and implements logic to sanitize text inputs and handle JSONB data safely, ensuring data integrity for conversation titles and descriptive text.

packages/@openmaic/storage/src/agent-session · high confidence

Added a new PostgreSQL-backed storage layer for session-scoped materials in \packages/@openmaic/storage/src/material\. This implementation introduces the \AgentSessionMaterialStore\ interface and its \pg.ts\ backend, which persists metadata for content assets (such as web pages, transcripts, and images) within the context of an agent session. The backend manages a dedicated \agent\_session\_materials\ table with constraints for material kinds and extraction states, handles durable extraction leasing, and ensures data integrity by referencing the agent session schema. It also includes type definitions for material kinds, extraction states, and asset references, enabling the system to track and retrieve session-specific content derived from source uploads or external fetches.

packages/@openmaic/storage/src/material · high confidence

Adds a new isolated render service for classroom video exports, running on Node 22 with headless Chromium and FFmpeg. The service provides an asynchronous HTTP API for submitting, polling, and downloading MP4 renders, along with a synchronous preview endpoint. To secure the rendering of untrusted HTML, the container enforces a strict iptables egress lockdown by default, blocking all outbound network traffic except loopback and established connections, and drops privileges to a non-root user after startup. The service includes configurable resource profiles (standard and low-memory), admission controls to manage concurrency and queue limits, and machine-readable health and admission status endpoints.

render-service · high confidence

The Pi agent location now supports a new 'native' child runtime mode alongside the existing 'legacy' mode, enabling scoped Spotlight and native whiteboard tools (additive and destructive) for child agents. The Director loop has been updated to pass this runtime mode and associated services (web search, whiteboard) to child agents, and to handle single PPT element references as evidence. Additionally, the Director context runtime is now evidence-aware, incorporating scene evidence and interactive state notes into the prompt, and includes a new compaction mechanism to manage context window limits during long conversations.

lib/chat/pi · high confidence

The @openmaic/storage package now provides a key-value storage primitive that distinguishes between 'account' scope (synced to a server via HTTP) and 'device' scope (kept strictly local). This includes a BrowserKVStore for local storage, an HttpKVStore for server-backed account data, and a kvPersistStorage adapter that allows Zustand stores to persist their state to this new KV backend instead of raw localStorage, ensuring device-local state never leaves the machine.

packages/@openmaic/storage/src/kv, packages/@openmaic/storage/src/zustand · high confidence

The application now supports a server-owned asset lifecycle where generated media is managed through an asset pool rather than direct client uploads, with mutations (PUT/DELETE) restricted to the server to prevent cross-user data corruption. A new persistence route handler (\/api/persistence\) manages document and asset storage, supporting an opt-in indirect byte egress mode (signed URL redirects) for assets. Additionally, a new \/api/stage-meta\ endpoint provides per-viewer ownership and publication status for documents, enabling the client to distinguish between read-only and editable views without exposing owner identities.

app/api/persistence · high confidence

Adds the Pro Workbench UI components, including the ProBadge toggle, the ProLaunchPanel composer for starting sessions, and the WorkbenchChat conversation surface with its timeline, autoscroll, and action-cluster rendering logic.

components/workbench · high confidence

This change adds a new whiteboard runtime store (lib/whiteboard/runtime) that manages whiteboard state via an append-only operation log, supporting operations like adding/deleting elements and editing code lines. It includes a legacy import mechanism to migrate existing whiteboards from the document store into the new runtime format, and fixes a rendering issue where the viewport ratio was inverted, ensuring boards now correctly display in 16:9 landscape.

lib/whiteboard · high confidence

The PBL v2 learning experience now relies on a new set of specialized agents located in \lib/pbl/v2/agents\. The Instructor agent manages the main teaching conversation, featuring a new memory compression system (\instructor-memory.ts\) to handle long chat threads and tier-specific guidance (\tier-guidance.ts\) that adjusts the depth of help based on learner proficiency. The Evaluator agent (\evaluator.ts\) handles structured feedback at task, milestone, and project completion stages, including specific logic for role-play scenarios. The Planner agent (\planner.ts\) generates the project structure in a single agentic pass, while the Simulator agent (\simulator.ts\) enables in-character role-play interactions for scenario-based projects. These components replace the previous v1 generation and runtime paths.

lib/pbl/v2/agents · high confidence

This change adds the core runtime logic for the PBL v2 learning engine, including checkpoint transport, proficiency tracking, and evaluation pipelines. It introduces a dynamic proficiency system that adjusts learner difficulty tiers based on real-time signals (observations, task speed, submission scores) and integrates pre-play quiz results to calibrate initial proficiency. The update also implements a deterministic, LLM-free completion report engine that generates distinct metrics for standard knowledge projects and scenario role-plays, alongside robust JSON-tail parsing to handle evaluator outputs. Additionally, it adds file-upload validation for text and image submissions and establishes the Zod schemas for Instructor tool arguments.

lib/pbl/v2/operations · high confidence

Authors now have a dedicated Pro mode editing interface that replaces the standard canvas view. This new shell provides a top CommandBar for undo/redo and global controls, a draggable FloatingInsertToolbar for adding content elements, and a FloatingToolbar for formatting selected items. It also includes a CanvasPager for navigating between scenes and a HintRail reserved for future AI coaching, creating a cohesive, persistent editing environment.

components/edit/EditShell · high confidence

This change adds the foundational library for the new Pro-mode 'Edit with AI' experience. It introduces an agent roster system (lib/edit/agent-ops.ts, lib/edit/agent-roster.ts) that allows users to author and manage classroom agents directly within the editor, complete with undo/redo history and role-based constraints. It also establishes a new slide editing surface (lib/edit/scene-editor-surface.ts, lib/edit/scene-edit-bridge.ts) that decouples the editor UI from the app, enabling a dedicated slide canvas with element-level operations, content validation (lib/edit/content-validation.ts), and a recycle bin for deleted scenes (lib/edit/deleted-scene-recycle.ts). Additionally, it includes utilities for precise text replacement (lib/edit/html-edit.ts) and layout management (lib/edit/contain-box.ts) to support the new interactive authoring workflow.

lib/edit · high confidence

The media layer now uses a unified asset pool to store and resolve media bytes, replacing previous ad-hoc caching. This change introduces a new asset manifest system that enumerates document references to prevent orphaned media from being included in exports. It also adds cross-tab synchronization for asset replacements via BroadcastChannel, ensuring that updates to media are reflected across open browser tabs. Additionally, the system now tracks storage capacity per course, marking stages as full when the store is exhausted and allowing retries once space is reclaimed.

lib/media · high confidence

This change adds a suite of new backend modules to the agent runtime. It introduces a dedicated model driver (\agent-driver-model.ts\) that enforces specific transport contracts and context-window handling for the agent, distinct from general model resolution. It adds an \ask\_user\ tool (\ask-user.ts\) allowing the agent to pause execution and request input or multiple-choice selections from the user. It also implements the backend logic for generating concise conversation titles (\conversation-title-generator.ts\, \conversation-title-task.ts\) and provides the core tooling for multi-stage curriculum management, including stage/folder CRUD, outline merging (\course-outline-union.ts\, \curriculum-tools.ts\), and document writing with sequential execution guarantees (\course-tools.ts\, \document-writes.ts\).

lib/server/agent-runtime · high confidence

This release adds the OpenMAIC 1.0.0 Workbench, providing a new \/workspace\ home and a comprehensive set of API routes for managing course documents (stages) and folders. Users can now create, list, rename, and delete courses and folders, as well as organize courses into folders via a new membership API. The workbench introduces real-time change detection through a polling-based freshness SSE stream and a manifest endpoint, allowing the UI to efficiently re-fetch only changed scenes. Additional capabilities include publishing and unpublishing courses, downloading skills as zips, and a backward-compatible launch bridge for legacy workbench links.

(repo-wide) · high confidence

A new health-check endpoint at /api/health has been added, returning the application version and a boolean status for each core capability (web search, image generation, video generation, and TTS). The availability of each capability is determined by checking whether at least one configured provider is enabled (respecting the force-disabled flag), and the response also indicates whether access-code protection is currently configured via the ACCESS\_CODE environment variable.

app/api/health · high confidence

The \@openmaic/generation\ package introduces a dedicated, provider-agnostic layer for scaffolding Project-Based Learning (PBL) projects and generating scene content. It exposes a clean \AICallFn\ interface so host applications can inject their own AI provider without the package managing configuration or persistence. The package includes packaged prompt assets for PBL single-call planning (designing project info, instructor roles, and milestones) and role-play scenario generation (defining settings, characters, and dramatic arcs). It also provides primitives for independent scene content, action, and assembly generation, allowing callers to build complete scenes with stable identity via \sceneId\ and handle failures through optional callbacks.

packages/@openmaic/generation · high confidence

A new API route at app/api/classroom-media/\[classroomId\]/\[...path\] has been added to serve media files (images, video, audio) stored in classroom directories. This endpoint supports HTTP range requests, enabling progressive playback and seeking for video and audio content without loading entire files into memory. It includes security measures such as path traversal prevention and symlink resolution to ensure files are served only from the intended classroom directory. Media files are served with appropriate MIME types and cache headers for improved performance.

app/api/classroom-media · high confidence

The Agent Bar component has been introduced to provide a centralized interface for managing agent voice settings, including a searchable popover for selecting TTS providers and voices, real-time audio previewing, and persistence of voice selections across reloads. Additionally, several UI components (agent-avatar, agent-config-panel, agent-reveal-modal) have been moved into the components/agent directory, and the i18n hook import path has been corrected to reflect the new structure.

components/agent · high confidence

This change introduces a suite of new scripts in the \scripts/\ directory to enforce quality and consistency across the \@openmaic\ workspace. \check-package-version-bumps.mjs\ ensures that changes to publishable package inputs trigger version bumps, while \check-internal-dependency-ranges.mjs\ enforces that internal dependencies use \workspace:^\ to prevent duplicate installations. \assert-pg-contract-suites.mjs\ validates that PostgreSQL contract tests actually ran against a real database by checking insert counters. Additional scripts include \check-i18n-keys.mjs\ for locale alignment, \check-node-engine-contract.mjs\ to verify Node version compatibility, \assert-vendor-maic-importer.mjs\ to ensure build artifacts are present, and \ci-run-parallel.sh\ to support parallel CI execution. Video export font generation scripts (\generate-video-export-katex.mjs\, \generate-video-export-noto-cjk.mjs\, \generate-video-export-noto-script-fonts.mjs\) and generation smoke tests (\generation-node-smoke.mjs\, \generation-node-smoke-server.mjs\) are also added.

scripts · high confidence

The storage layer now provides a unified DocumentStore interface for persisting course documents, featuring three distinct backends: a browser-based IndexedDB store, an HTTP client for server-backed storage, and a PostgreSQL backend for production use. This change introduces a normalized document aggregate model that splits documents into stage, scene, and outline rows for efficient storage and retrieval, along with automatic DSL version migration on read. Users benefit from consistent document persistence across environments, with the PostgreSQL backend supporting folder organization and asset reference tracking.

packages/@openmaic/storage/src/document · high confidence

The eval/outline-language directory now provides a complete evaluation harness to verify that the AI course generation system correctly infers teaching languages from user requirements. The runner (runner.ts) executes real outline generation via generateSceneOutlinesFromRequirements and then uses a separate LLM-as-judge (judge.ts) to score the inferred language directive against ground-truth expectations using a lenient rubric. Results are written to structured Markdown reports (reporter.ts, shared/markdown-report.ts) that include pass/fail details and summary tables, with test scenarios covering diverse languages (Chinese, English, Spanish, German, Arabic, Japanese, Korean) and edge cases like immersive learning, explicit language overrides, and cross-language PDFs.

eval/outline-language · high confidence

A new evaluation harness has been added to the \eval/pbl-v2-planner\ directory to compare the legacy agentic planner (\loop\) against the new single structured-output planner (\single-call\). The harness (\runner.ts\) executes test cases against both variants and uses LLM-based judges to score output quality and runtime completability (checking if a learner can actually finish the generated project). Results are saved as JSON and can be inspected via a new static HTML report generator (\build-compare.ts\) or a local development server (\serve.ts\) that provides a side-by-side A/B viewer for generated projects and judge scores.

eval/pbl-v2-planner · high confidence

The PBL v2 runtime now manages learner state through a dedicated persistence layer in lib/pbl/v2/runtime. This introduces a dual-write mechanism where runtime and engagement events are drained from client-side outboxes into the RuntimeStore, and learner state is folded from these records to reconstruct the current session. The system ensures data integrity by stripping learner state to a design template before document persistence, while maintaining a full snapshot in the RuntimeStore to allow for state recovery and hydration. This change decouples the active runtime state from the static project document, enabling more robust state management and recovery for PBL v2 projects.

lib/pbl/v2/runtime · high confidence

A new API endpoint at /api/verify-pdf-provider allows users to validate connectivity and credentials for PDF parsing providers (AliDocMind, MinerU Cloud, and self-hosted options). The implementation enforces strict security controls: server-configured providers ignore client-supplied URLs and keys, all client-provided endpoints are validated against SSRF attacks, and outbound requests disable HTTP redirects. It also adds structured error handling for connection failures (DNS, timeouts, refused connections) and logs detailed context for debugging.

app/api/verify-pdf-provider · high confidence

The edit interface now uses a dedicated Pro-mode chrome assembly. A new five-slot grid layout (StageGrid) anchors the slide navigation rail on the left and reserves space for a bottom actions timeline and a right-side AI panel. The ContainBox component ensures the 16:9 stage canvas maintains its aspect ratio and settles correctly during layout transitions. EditChromeRoot manages the Pro-mode UI, including deck paging and the new narration timeline, while PlaybackChromeRoot handles the non-edit playback experience with action-level navigation and element referencing.

components/edit · high confidence

The \@openmaic/renderer\ package now provides a complete React-based rendering engine for slides, replacing the previous implementation. This new renderer introduces a \SlideCanvas\ component that manages slide layout, scaling, and background styling, and a \SlideElement\ dispatcher that renders specific content types including text, images, shapes, tables, audio, video, code, and charts. It adds support for presentation-time visual effects such as spotlights, laser pointers, highlights, and zoom transitions via dedicated overlay components. Chart rendering is now handled by a lazy-loaded ECharts runtime, and code blocks feature syntax highlighting with Shiki and animated typing reveals. The renderer also ensures accurate font rendering for imported PPTX files by generating self-hosted CSS for Chinese fonts and inlining KaTeX math fonts as data URLs to bypass cross-origin restrictions during snapshot generation.

packages/@openmaic/renderer/src · high confidence

The storage package now includes a new \RuntimeStore\ interface and its implementations for browser (IndexedDB) and server (PostgreSQL, HTTP) environments. This introduces a dedicated persistence layer for learner runtime data, managing \RuntimeSession\ objects and their append-only \RuntimeRecord\s. The browser backend stores sessions and records in IndexedDB with partitioned indexes, while the server backend uses PostgreSQL JSONB columns and validates payloads to ensure lossless JSON round-tripping. Both implementations enforce strict versioning, payload validation (defaulting to DSL skeletons for chat and quiz attempts), and migration logic to handle schema changes safely.

packages/@openmaic/storage/src/runtime · high confidence

The editor now features a new Slide Navigation Rail (SlideNavRail) that provides a vertical strip of scene thumbnails for navigation and management. This component allows users to reorder scenes via drag-and-drop, resize the rail width, and insert new slides or quizzes between existing ones using a hover-revealed insertion zone. It also supports inline renaming of scene titles and displays visual indicators for scenes with incomplete content.

components/edit/SlideNavRail · high confidence

The \@openmaic/importer\ package now uses a new TypeScript implementation to parse .pptx files into OpenMAIC canvas slides. This update introduces high-fidelity math support by converting Equation.3 OLE formulas via MTEF v3, with a fallback to JS-based conversion. It also improves fidelity for PPTX content by preserving tab columns, text insets, arrow rendering, shape autofit sizes, and Wingdings checkmarks. The importer now handles embedded videos by uploading posters and includes a degrade-not-fail policy that surfaces telemetry warnings for any content that could not be fully converted, ensuring the import process never fails due to partial content loss.

packages/@openmaic/importer/src · high confidence

The storage package introduces a new asset management system that replaces the previous content-addressed model with an allocated-identity registry. This change provides stable asset IDs that remain valid even when the underlying bytes are replaced, while still supporting byte deduplication via content hashing. The architecture separates the registry (managing IDs, metadata, and references) from the byte storage layer, which is now pluggable: the browser backend uses an inline IndexedDB implementation, while the server backend supports a pluggable PostgreSQL byte store with an offline reclamation collector to prevent self-deadlocks. This new system includes a new database schema (\asset\_entries\, \asset\_blobs\, \document\_asset\_refs\), an offline collector for unreferenced assets, and an HTTP store for server-side asset access, fundamentally changing how assets are stored, referenced, and cleaned up.

packages/@openmaic/storage/src/asset · high confidence

Added \use-import-classroom.ts\ and \use-import-pptx.ts\ to enable importing content from classroom ZIP archives and PowerPoint files. The classroom importer handles media persistence (uploading assets to the server pool when available) and rewrites internal references to ensure imported slides and media are correctly linked. The PPTX importer dynamically loads the \maic-importer\ bundle to parse presentations, supporting optional media uploads and providing user-facing feedback via toast notifications.

lib/import · high confidence

A new API route at app/api/extract-document has been introduced to handle document and media extraction. This endpoint supports uploading files directly or referencing existing assets by ID, and it processes various formats including PDFs, DOCX, PPTX, and media files (audio/video) via the AliDocMind provider. Security has been strengthened by adding SSRF protection for outbound URLs and strict input validation that prevents echoing user-supplied provider IDs or MIME types in error messages. The system also includes a configurable fallback to MinerU Cloud, which is disabled by default and requires explicit operator opt-in via an environment variable to prevent silent data leakage to third-party services.

app/api/extract-document · high confidence

The document processing library has been restructured to support a provider-based extraction pipeline. Users can now upload a wider range of formats, including audio and video files (MP3, MP4, etc.) which are processed via local ffmpeg or the AliDocMind provider to extract transcripts and keyframes. The system introduces a browser-safe manifest to track supported formats and extractor capabilities, and adds logic to bundle multiple document sources into a single context with intelligent text budgeting and image selection for vision models. Legacy session data is automatically migrated to the new structured source format.

lib/document · high confidence

The \lib/document-store\ module has been replaced with a new persistence architecture that supports server-backed document storage (via HTTP and Postgres) alongside the existing browser IndexedDB backend. Users can now configure a server-backed store at bootstrap, which enforces app-specific validation rules for scenes and stages at the write boundary. The system includes a migration path that automatically converts legacy document formats and media references to the new schema, ensuring backward compatibility. Device-scoped editor state (current scene position) is now separated from canonical document metadata to prevent conflicts during concurrent edits. The new store also handles undefined field omission and generation-based conflict resolution to improve data integrity.

lib/document-store · high confidence

A new Agent Roster panel has been added to the editor, allowing users to view and edit the classroom agent configuration directly within the stage document. This feature introduces a dialog-based interface where users can add, remove, rename, and reorder AI classmates, as well as edit their personas and avatars. The roster is now a single source of truth stored on the stage document, ensuring that changes persist through the pending-change scheduler and are immediately reflected in the agent registry.

components/edit/AgentsView · high confidence

The platform now supports image and video generation through several new provider adapters. Users can generate images via ComfyUI (local or remote), Grok (xAI), Lemonade, MiniMax, OpenAI, and OpenRouter. Video generation is now available through Grok, HappyHorse (Alibaba Cloud), MiniMax, OpenRouter, and Kling. These adapters handle provider-specific authentication, workflow loading (for ComfyUI), and asynchronous task polling, expanding the range of available AI media models.

lib/media/adapters · high confidence

A new API endpoint at /api/provider/probe-models allows users to automatically discover available chat models for a given provider by supplying a base URL and API key. The endpoint filters out non-chat models (such as TTS, ASR, or embedding models) and returns a clean list of chat-compatible models. To ensure security, the implementation includes SSRF guards on both the base URL and any optional models URL override, and explicitly blocks HTTP redirects to prevent potential security vulnerabilities.

app/api/provider · high confidence

The render-service now includes a new backend implementation that introduces bounded, single-process orchestration for distributed rendering primitives via a new chunk-executor and chunk-worker, allowing renders to be split into parallel chunks with configurable worker caps. It adds a new POST /preview endpoint for synchronous single-page previews, secured by a PreviewGate that enforces per-user and global concurrency limits. To protect against untrusted input, the service hardens extracted project HTML with Content Security Policy injection and sanitizes SVG/XHTML documents, while also enforcing strict upload size caps via a byte-capped stream wrapper. Operational visibility is improved through machine-readable lifecycle events emitted to stdout, and the service supports horizontal scaling through abstracted JobStore and ArtifactStore interfaces (defaulting to in-memory and local disk).

render-service/src · high confidence

The \lib/video-export-app\ module introduces a new browser-side video export system that compiles the current stage into a self-contained Hyperframes project ZIP. This ZIP bundles the interactive HTML, collected media assets (with CDN fallbacks for live-mode), and vendored GSAP, ensuring deterministic, offline-ready exports. The system supports two paths: downloading the ZIP for local CLI rendering or uploading it to a service-backed MP4 renderer for in-app one-click export. It also includes a fast subtitles-only download path (SRT/VTT) and ensures deterministic Quiz layouts and cover cards across locales.

lib/video-export-app · high confidence

Added a new \lib/server/agent-runtime/course-edit\ module that exposes agent-facing tools for managing course structure and content. The \tools.ts\ file implements \generate\_tts\ (synthesizing narration audio for scenes) and \edit\_deck\ (retitle, insert, delete, and reorder course pages/scenes). Supporting this, \apply.ts\ provides the core logic for applying JSON Pointer patches to slide elements and inventorying slide content, while \element-schema.ts\ defines strict TypeBox validation schemas for the slide DSL to ensure data integrity. Additionally, \media-byte-omission.ts\ introduces an optimization to calculate inline media byte lengths without full decoding, replacing large allocations with arithmetic checks to stay within model token budgets.

lib/server/agent-runtime/course-edit · high confidence

The chat module now includes a new \agent-loop.ts\ that extracts the core multi-agent loop logic into a shared, framework-agnostic function, allowing both the frontend hook and the evaluation harness to use the same execution path. This loop integrates with the runtime store to include post-submit quiz results in the context sent to the chat agent, ensuring the agent has access to graded answers and feedback. Additionally, a new \lecture-notes.ts\ utility was added to build structured lecture notes from scene actions, and \action-translations.ts\ was updated with minor formatting changes.

lib/chat · high confidence

The slide editor now features a new surface implementation that introduces selection-anchored floating bars for editing elements. When a text element is selected, a format bar appears; when a non-text element (like an image or shape) is selected, a contextual bar with z-order and delete controls appears. Image elements also gain specific actions for replacing, flipping, and cropping. The editor includes a new color picker with an eyedropper tool for setting solid colors and an image picker for backgrounds. A new canvas overlay system manages the z-ordering of floating UI elements like the insert palette and element picker, ensuring they remain visible even when the canvas has overflow hidden. The slide canvas now supports a new renderer-based editor mode, toggled by a feature flag, which integrates with these new UI components.

components/edit/surfaces/slide · high confidence

This change introduces a new \lib/store\ module that centralizes state management for the editor surface, persistence, and interactive scenes. It adds stores for managing draft element and course references (ensuring they are scoped to the active chat session and cleared after sending), a keep-alive pool for interactive iframes to prevent state loss during scene switches, and a robust KV-based persistence layer with a state machine to handle backend failures and health reporting. Additionally, it includes stores for video render progress, whiteboard history, and canvas viewport synchronization.

lib/store · high confidence

Authors can now edit quiz scenes using a dedicated form-based interface instead of a canvas. This new surface supports single-choice, multiple-choice, and short-answer questions, allowing users to add, delete, and reorder questions and options via drag-and-drop handles. The editor includes an inline 'Add question' menu, per-question expansion for editing details, and a full undo/redo history that coalesces typing into single steps. Validation hints guide authors to fix missing questions, options, or correct answers before publishing.

components/edit/surfaces/quiz · high confidence

This change introduces a new GET /api/usage endpoint that aggregates deployment-wide usage logs by model, day, and modality, exposing totals for requests and LLM tokens along with detailed breakdowns. To support this, a new normalization layer in lib/usage/normalize.ts maps AI SDK v6 usage data into a standardized four-class token structure (input, output, cache read, cache creation) plus reasoning tokens, ensuring consistent billing and display metrics across providers.

app/api/usage, lib/usage · high confidence

A new evaluation page has been added at app/eval/whiteboard/page.tsx to support quality assessments of whiteboard layouts. This page initializes a synthetic stage and scene within the application store, renders slide elements using the existing ScreenElement component, and exposes a global window setter (\_\_setElements) to allow external test runners (specifically Playwright) to inject elements and verify rendering behavior.

app/eval · high confidence

A new automated evaluation harness has been added to the \eval/whiteboard-layout\ directory to assess the quality of AI-generated whiteboard layouts. The system runs predefined scenarios (covering subjects like math, physics, and finance) by driving a headless browser via Playwright to capture screenshots of the whiteboard at specific checkpoints. It then uses a Vision Language Model (VLM) to score these screenshots against a rubric covering readability, overlap, rendering correctness, content completeness, and layout logic. The harness supports both single-agent and multi-agent discussion modes, allows toggling of 'thinking' modes to measure latency trade-offs, and generates detailed JSON and Markdown reports with summary statistics and per-scenario results.

eval/whiteboard-layout · high confidence

Users can now apply multi-modal token plans (e.g., TokenDance, MiniMax) with a single API key, which automatically configures and enables LLM, image, video, TTS, and web search providers. The settings page also introduces new feature flags to gate experimental capabilities, including the Pro workbench, MAIC Editor, playback canvas, Pi-based classroom chat, and video export.

lib/config · high confidence

The persistence layer now supports server-backed asset storage, allowing generated media and uploaded materials to be persisted beyond the browser session. When the ASSET\_S3\_BUCKET environment variable is configured, asset bytes are stored in Amazon S3 instead of PostgreSQL, with lazy initialization to prevent startup failures. The system introduces an automated asset collector that runs periodically (defaulting to every 15 minutes) to reclaim unreferenced assets based on configurable grace periods (ASSET\_COLLECTION\_GRACE\_MS) and pending TTLs (ASSET\_PENDING\_TTL\_MS). A deployment-wide quota (ASSET\_QUOTA\_BYTES, defaulting to 10 GiB) prevents unbounded storage growth. The asset lifecycle is tied to document ownership: when a course is deleted, its assets are released from the registry and eventually reclaimed by the collector. The system also includes validation for S3 bucket names, proper handling of JSONB writes with NUL characters, and indirect byte egress via signed URLs that respect the collection grace period.

lib/persistence · high confidence

The storage package now includes a server-backed runtime that exposes HTTP handlers for assets, documents, and learner runtime data, all persisted via a new Postgres backend. Deployments can opt into indirect byte egress for assets (returning signed URLs instead of serving bytes directly), and the reference server provides a runnable example using bearer-token authentication and a PostgreSQL connection pool. This change introduces the HTTP contract layer and Postgres-backed stores that replace the previous in-memory or file-based storage mechanisms.

packages/@openmaic/storage/src/server · high confidence

This change introduces server-side access-code protection with startup warnings for missing or short codes, HMAC-signed access tokens (Node and Edge verifiers) for authentication, and a sliding-window attempt limiter to throttle brute-force verification attempts. It also adds the core infrastructure for asynchronous classroom generation, including job tracking, media persistence, and file-backed storage with exclusive ID reservation to prevent collisions.

lib/server · high confidence

The video export workflow now supports generating MP4 files via an external render service instead of only producing local ZIP archives. Users can submit export jobs through the new API routes, which stream the upload to the service, poll for job status, and download the final MP4 directly (or via a presigned storage URL). The system also exposes a capability check so the UI can hide the MP4 option if the render service is unavailable, ensuring a graceful fallback to ZIP downloads.

app/api/export-video · high confidence

A new \lib/choreography\ module centralizes the playback semantics previously scattered across the app's engines, ensuring the classroom-video exporter matches the live app exactly. This includes a deterministic playback cursor (\resolvePlaybackCursor\) that handles scene/action navigation and empty-scene dwell, a shared timing specification for action durations (whiteboard, speech, video, effects), and a versioned, declarative animation descriptor system (e.g., \spotlight.v1\, \laser.v1\) that defines effect geometry, easing, and compositing rules. By moving these pure, backend-agnostic definitions into a single source of truth, the exporter can now faithfully reproduce the app's visual timing and effect behavior without re-implementing or drifting from the runtime logic.

lib/choreography · high confidence

The application now supports site-level access code authentication, introducing an \AccessCodeGuard\ component that gates access and an \AccessCodeModal\ for user entry, which also triggers a server provider re-fetch upon successful authentication to ensure configured providers are available. The user interface has been modernized with a new \LanguageSwitcher\ component replacing the previous inline language toggle, and the \Header\ has been refactored to support flexible control slots (such as \backControl\ and \hideGlobalControls\) for different workbench modes. Additionally, several legacy components (\AgentBar\, \GenerationToolbar\, \MediaPopover\, \TtsConfigPopover\) have been removed as part of a broader UI restructuring.

components · high confidence

The application now supports site-level authentication via an environment variable ACCESS\_CODE. When enabled, the new /api/access-code/verify endpoint validates submitted codes using constant-time comparison and issues an httpOnly cookie upon success. To prevent brute-force attacks, verification attempts are throttled based on client identity, with stricter enforcement for trusted proxy identities. The /api/access-code/status endpoint allows clients to check if the feature is enabled and whether they are currently authenticated.

app/api/access-code · high confidence

The video export pipeline now compiles a pure, deterministic intermediate representation (IR) of the video timeline, enabling the generation of self-contained static interactive HTML pages for Quiz and PBL scenes. This change introduces a new compile pipeline that processes scenes through a series of pure passes (normalize, probe, timeline, visuals, interactive, reflow, geometry, assets) to produce a \VideoTimeline\ IR. The system now supports emitting this IR into a Hyperframes-based composition, allowing for the creation of static, offline-capable interactive content that mirrors the live app's behavior without requiring a live DOM or external dependencies like FFmpeg or Chrome during the compile phase. Additionally, the export now includes deterministic cover cards for Quizzes and PBLs, and supports embedding interactive HTML directly into the exported video frames.

lib/video-export · high confidence

The web search capability has been expanded from a single Tavily integration to a multi-provider system. New supported providers include Baidu (with toggleable sub-sources for web, Baike, and Scholar), Brave (API and HTML scrape fallback), Claude (using native web search tools), Exa, MiniMax, Doubao, SearXNG, and Bocha. The system now routes queries to the selected provider via a central dispatcher, allowing users to choose their preferred search source. Configuration has been updated to support provider-specific settings like API keys, base URLs, and model selection for Claude.

lib/web-search · high confidence

The workbench is now version 1.0.0, introducing a new agent lifecycle event system (including media generation and stage link events), a shared registry for agent skills, and a completely rewritten composer with new tokenization, skill handling, and menu logic. It also adds new classroom navigation controls and session bootstrap logic.

lib/workbench · high confidence

The application no longer exposes the previous generation endpoints (\/api/generate\, \/api/generate/scene-outlines\, \/api/generate/scene\) which handled multi-stage AI pipelines and single-scene generation. Additionally, the \CanvasTool\ component, which provided the slide editor's toolbar with undo/redo, zoom, and element insertion capabilities, has been removed. These changes indicate a shift away from the prior generation and editing architecture.

(repo-wide) · high confidence

The v1 Project-Based Learning (PBL) generation implementation has been removed from the codebase. Specifically, the \lib/pbl/mcp\ directory no longer contains the \AgentMCP\, \IssueboardMCP\, \ModeMCP\, \ProjectMCP\, and \agent-templates\ modules that previously managed agent roles, issue workflows, and project configuration during the v1 generation process. This change eliminates the legacy v1 write path and associated dead UI, requiring users to rely on the v2 generation architecture.

lib/pbl/mcp · high confidence

The large, standalone \lib/generation/generation-pipeline.ts\ file has been deleted. This change removes the legacy two-stage generation system (which handled scene outlines and full scene generation independently) from the codebase, indicating a consolidation or migration to a different generation architecture.

lib/generation · high confidence

The ThumbnailSlide component and its associated ThumbnailElement helper have been removed from the slide renderer. This eliminates the previous implementation that rendered slide thumbnails by scaling individual base elements (images, text, shapes, etc.) within a CSS-transformed container.

components/slide-renderer/components/ThumbnailSlide · high confidence

The legacy PBL Chat API route (\app/api/pbl/chat/route.ts\) has been removed. This endpoint previously handled student interactions by routing @mention requests to specific agents (such as 'question' or 'judge') and generating LLM responses based on issue context and conversation history. Its removal signifies the completion of the migration to the v2 write path, meaning users must now use the updated API endpoints for PBL runtime chat functionality.

app/api/pbl/chat · high confidence

The ThumbnailInteractive component now renders interactive slide previews in an iframe with a stricter sandbox policy. The sandbox attribute is set to 'allow-scripts allow-forms allow-popups', explicitly removing the 'allow-same-origin' permission. This change prevents the embedded content from accessing the parent page's origin, mitigating potential cross-origin security risks while still allowing scripts, forms, and popups to function within the thumbnail preview.

components/slide-renderer/components/ThumbnailInteractive · high confidence

The monolithic audio handling logic has been decomposed into a set of focused, single-responsibility modules within lib/audio. This refactoring introduces dedicated files for specific capabilities: narration adoption and persistence (adopt-cached-narration, persist-narration-reference, narration-allocations), provider enablement and configuration (provider-enablement, provider-display, asr-enablement), and specialized audio processing (audio-duration for WAV/MP3 parsing, discussion-audio for element reuse, browser-tts-preview for language detection and playback). It also adds support for new features like Qwen voice cloning (qwen-voice-clone, qwen-voice-clone-registration) and agent voice resolution (agent-voice), while removing dead code and consolidating logic to improve testability and maintainability.

lib/audio · high confidence

The monolithic \lib/api/stage-api.ts\ has been split into distinct, namespace-based modules (\stage-api-scene\, \stage-api-element\, \stage-api-canvas\, \stage-api-navigation\, \stage-api-whiteboard\, \stage-api-mode\, and \stage-api-defaults\) to improve code organization and maintainability. This change introduces factory functions for each namespace (e.g., \createSceneAPI\, \createElementAPI\) that encapsulate specific operations like scene CRUD, element management, canvas effects (highlight, spotlight), and navigation, while re-exporting shared types and utilities from the main entry point for backward compatibility.

lib/api · high confidence

The server-providers API endpoint now includes a new 'generation' field in its response, exposing the current parallel scene concurrency setting via the getParallelSceneConcurrency function. This allows clients to query the configured limit for parallel scene generation tasks. The change also includes minor formatting adjustments to the error handling block.

app/api/server-providers · high confidence

The agent registry now persists user-selected agent modes and specific agent choices across classroom reloads, ensuring that explicit selections (whether preset or auto-generated) are respected while preventing auto-generated agents from incorrectly bleeding into preset classrooms. Additionally, the agent configuration schema has been extended to support per-agent TTS voice settings, including both specific provider/model/voice IDs and provider-neutral voice designs, allowing for more granular voice assignment and stability.

lib/orchestration/registry · high confidence

Chat sessions now persist to the centralized RuntimeStore instead of the legacy IndexedDB tables, providing append-only runtime records and a single source of truth for session state. The update includes a one-time migration path that converts existing legacy chat rows into the new format, handling timestamp repairs and schema differences. To ensure data integrity during this transition and concurrent access, the system introduces a new locking mechanism (using Web Locks with a fallback) for exclusive and shared access to chat storage partitions, and implements a robust sync plan that handles session creation, reuse, and replacement with retry logic. Legacy playback state storage for chats has been removed as it is no longer needed with the new store.

lib/utils · high confidence

When a discussion or Q&A session is semantically closed by the server, the chat area now enters a 'soft-closing' state instead of ending immediately. A countdown timer is displayed in the session header and the session card, giving the user a brief window to manually continue the session before it is automatically finalized. The session list now visually indicates this state with an amber pulsing dot, and the chat session component exposes a 'Continue' action to extend the interaction.

components/chat · high confidence

The /api/generate-classroom endpoint no longer blocks the HTTP request while generating content. Instead, it validates the input, creates a background job, and returns immediately, allowing the system to process the generation asynchronously. This change improves API responsiveness and prevents timeouts for long-running generation tasks.

app/api/generate-classroom · high confidence

The ClassroomSurface component now ensures that transient load failures do not incorrectly trigger the 'not found' card. By separating the 'absent' outcome (indicating a course is genuinely deleted or never existed) from 'unavailable' or error states, the UI now correctly offers a retry option for temporary issues while reserving the terminal 'not found' view only for confirmed absences, improving the user experience when courses are temporarily inaccessible.

components/classroom · high confidence

The classroom module has been reorganized into dedicated files to improve separation of concerns and reliability. \load-classroom.ts\ now centralizes the classroom loading flow, distinguishing between 'found', 'absent', and 'unavailable' outcomes to prevent transient network errors from being treated as missing courses. \stage-ownership-signal.ts\ and \generation-permission.ts\ introduce a robust ownership gate that tracks viewer permissions (owner, not-owner, ownerless, unresolved) and prevents unauthorized generation spending under server-backed persistence. \complete-summary.ts\ adds logic to calculate and display quiz scores and scene counts for the end-of-course summary. \pbl-fallback-hydration.ts\ handles the migration and hydration of legacy scenes and chat sessions. \progressive-load-policy.ts\ manages the UI state transitions and retry logic for loading panes. \stage-meta-client.ts\ provides a dedicated client for fetching viewer-specific metadata. \use-classroom-session.ts\ orchestrates the lifecycle of a single course instance, including ownership refreshes and resource cleanup.

lib/classroom · high confidence

The classroom detail page has been refactored to replace the previous inline implementation (which managed loading states, error handling, and the Stage component directly) with a single \<ClassroomSurface\> component. This change simplifies the page structure by delegating rendering logic to the new surface component, which accepts the classroom ID and a 'page' variant prop.

app/classroom · high confidence

The slide editor now renders laser pointer and spotlight cues directly on the editing canvas, matching the playback experience. This is achieved by introducing a \LaserPointerOverlay\ and updating \SpotlightOverlay\ to resolve motion layers from descriptors (via \motion-descriptor-adapter\), allowing cues to target elements using the editor's DOM ID prefix. The \ScreenCanvas\ is now exposed as \PlaybackScreenCanvas\, which conditionally renders the new \RendererScreenCanvas\ (handling media playback states and retry logic) when the playback renderer feature flag is enabled, while the main \SlideEditor\ switches to this component in non-autonomous modes.

components/slide-renderer/Editor · high confidence

The slide-renderer Editor Canvas components now import their type definitions (such as PPTElement, SlideBackground, and various element types) from the @openmaic/dsl package instead of the local @/lib/types/slides module, centralizing the slide data model. Additionally, when a text element is actively being edited, the canvas no longer renders the redundant dashed selection border around it, providing a cleaner editing view while keeping resize and rotate handles visible.

components/slide-renderer/Editor/Canvas · high confidence

The TTS generation endpoint now enforces server-side provider configuration, ignoring client-supplied API keys and base URLs for admin-managed providers to prevent SSRF and credential leakage. It introduces structured error handling for rate limits (HTTP 429) and invalid responses, adds usage recording for billing/monitoring, and supports new capabilities like Qwen voice cloning and VoxCPM auto-voice registration via a dedicated voice API. Provider enablement is now centrally controlled, and model selection is unified per provider.

app/api/generate/tts · high confidence

The canvas area now supports a new 'element pick' mode, allowing users to select specific slide elements (such as text, images, or charts) for referencing, facilitated by a new \SlideElementPickOverlay\ component. Additionally, presentation mode has been refined with a dedicated toggle button in the toolbar, and the canvas now displays a completion page overlay when a course finishes during scene loading. The toolbar itself has been updated to include controls for soft-close countdowns and presentation state, and the component structure has been reorganized by moving canvas-related files into a dedicated \components/canvas\ directory.

components/canvas · high confidence

The storage layer now enforces strict validation on HTTP base URLs to prevent misconfiguration attacks, rejecting invalid schemes, embedded credentials, control characters, and ambiguous path forms. Additionally, it introduces sanitization for PostgreSQL JSONB writes, replacing null bytes and lone surrogates with replacement characters to prevent SQL errors when agent session data contains invalid Unicode sequences.

packages/@openmaic/storage/src · high confidence

The build configuration now uses an ESM import for the TypeScript compiler in the Rollup setup, which improves compatibility with modern bundlers. Additionally, dynamic imports for Node.js built-in modules (fs, https) are annotated with webpack ignore comments to prevent bundling errors in browser environments. Minor typo corrections in comments and internal logic handling for placeholder options were also applied.

packages/pptxgenjs · high confidence

The slide editor now correctly renders non-Latin scripts (such as Cyrillic and Vietnamese) by switching the UI font from Next.js's \next/font\ to \@fontsource\'s unicode-range-subsetted Inter, ensuring consistent typeface across all languages. Additionally, the application prevents horizontal layout shifts when opening modals or resizing content by enforcing a stable vertical scrollbar and neutralizing redundant spacing from Radix modal overlays.

app · high confidence

The quiz grading API now enforces stricter input validation by rejecting requests where the 'points' field is not a positive finite number. Model resolution has been refactored to use a centralized helper that supports per-model thinking configurations, replacing the previous manual header parsing. Additionally, error logging has been enhanced to include specific context (the first 60 characters of the question and the points value) to aid in debugging grading failures.

app/api/quiz-grade · high confidence

The client-side logic for applying AI-generated changes has been refined to preserve the user's existing slide canvas (including theme and viewport) while only updating elements and background, and to correctly handle interactive HTML edits by updating the content in place. Additionally, scene outlines are now matched using a stable unique identifier rather than mutable order indices, preventing incorrect outline associations when slides are reordered.

lib/agent/client · high confidence

The speech button now automatically cancels an active recording if the component is disabled while the user is still speaking, preventing the microphone from staying open indefinitely. It also gates its availability based on ASR (Automatic Speech Recognition) support, ensuring the button is disabled when speech-to-text is unavailable or not configured. Additionally, a new TTS configuration popover has been added, allowing users to preview and select voices for providers like VoxCPM and Qwen, with support for displaying localized voice names.

components/audio · high confidence

Interactive scenes now persist their iframe state across mode switches and remounts, preventing unnecessary reloads and preserving the user's position in the content. The legacy PBL v1 UI components (chat, issueboard, role selection) have been removed in favor of the new PBL v2 workspace, which features a persistent, non-remounting workspace frame that maintains scroll position and in-flight streams during expand/collapse toggles. Additionally, the classroom completion page now displays a confetti animation and trophy icon upon course completion.

components/scene-renderers · high confidence

The agent runtime now enforces stricter safety and reliability controls. Tool execution is gated by a configurable allowlist, preventing the agent from invoking tools that are not explicitly enabled for the current build. Additionally, every tool call is now subject to a global execution timeout (defaulting to 10 minutes, with specific overrides for long-running tools like scene generation) and respects caller abort signals, ensuring that hung or unresponsive tools no longer wedge the session indefinitely. The runtime also includes a stub quota hook and improved handling of provider-specific metadata to support multi-turn tool conversations.

lib/agent/runtime · high confidence

The runtime layer now supports pluggable backends via a new \configureRuntimeStorage\ API, allowing the default browser IndexedDB to be replaced by server-backed stores (e.g., HTTP/Postgres) for chat, quizzes, and whiteboards. It also introduces a device-anonymous learner identity system that generates and persists a unique key per device, enabling data partitioning and future migration to signed-in accounts. The change includes a safe, timeout-bounded cascade to delete runtime data when stages are removed, ensuring the runtime store does not block main app operations.

lib/runtime · high confidence

The application's localization system has been refactored from a manual TypeScript object merger to the i18next framework, enabling dynamic loading of translation resources and supporting 12 languages (including Arabic, German, Japanese, Korean, Russian, Vietnamese, and others) instead of the previous two. This change introduces a new configuration layer (\config.ts\) and a registry (\locales.ts\), while consolidating product copy for the workbench chat into a shared TypeScript module (\workbench.ts\) to ensure consistency across hook-based and hook-free components. The migration also includes a comprehensive translation guide (\TRANSLATION\_GUIDE.md\) to standardize how new locales are added and how specific UX keys should be handled.

lib/i18n · high confidence

The orchestration layer now includes a new set of summarizer modules in lib/orchestration/summarizers to keep agent context bounded and readable. code-line-budget.ts enforces a shared character budget for code blocks, rendering full content for the most recent lines, bare IDs for the next tier, and an omitted count for the rest, preventing unbounded prompt growth. state-context.ts and whiteboard-ledger.ts use this budget to summarize slide elements and replay per-round code edits, while whiteboard-conflicts.ts detects geometric overlaps and canvas clipping to alert the agent. conversation-summary.ts and message-converter.ts handle conversation history by stripping display prefixes, truncating content, and converting UI messages (including action results and interruption markers) into a clean OpenAI-format stream for the director agent.

lib/orchestration/summarizers · high confidence

The slide-renderer component now uses a dedicated \SlideThumbnail\ component that renders read-only slide previews via the external \@openmaic/renderer\ package. This change introduces robust media handling for thumbnails: it resolves image and video sources through the asset pool, displays appropriate states for pending, failed, or disabled media, and provides a retry button for failed media resolutions. Additionally, video thumbnails are styled with a muted, play-badge treatment instead of standard controls, and the component supports lazy loading and explicit sizing constraints.

components/slide-renderer · high confidence

The scene outlines streaming API now emits \languageDirective\ and \courseTitle\ events, allowing the frontend to display the inferred language and a concise course name incrementally. Performance is improved by fixing the outline extraction logic to run in O(n) time instead of O(n²), ensuring smoother streaming for large responses. The route also imports generation utilities from the \@openmaic/generation\ package and resolves vision images and model configuration via dedicated helper functions.

app/api/generate/scene-outlines-stream · high confidence

This change introduces the PBL v2 data model and runtime types, replacing the v1 schema. It includes a legacy read module that automatically upgrades existing v1 project data to the v2 format so historical scenes remain accessible. The update also adds Server-Sent Events (SSE) utilities for streaming chat interactions, defining specific event types for text deltas, tool calls, and project state patches, alongside locale handling to sync project language with the user's UI settings.

lib/pbl/v2 · high confidence

The prompt loading system in lib/prompts has been updated to support conditional content blocks using the {{\#if condition}}...{{/if}} syntax, allowing templates to include or exclude sections based on variable flags. The previous caching mechanism has been removed in favor of direct file I/O, meaning template changes take effect immediately without a restart. Additionally, the set of available prompt IDs and reusable snippets has been replaced; old generation-specific prompts (like slide-content and quiz-content) are gone, replaced by new IDs such as interactive-outlines and agent-system variants, and new media-related snippets (image-instructions, video-instructions) are now available for use in templates.

lib/prompts · high confidence

The quiz module in lib/quiz has been rewritten to support persistent state via RuntimeStore, precise answer-key resolution, and LaTeX formula rendering. Grading (grading.ts) now resolves stored answer keys to option values before comparison to ensure correct scoring, and distinguishes short-answer questions for AI grading. Persistence (persistence.ts) introduces a one-time migration from legacy localStorage keys to the new RuntimeStore, including a draft-recovery journal for crash safety. Runtime management (runtime.ts) serializes quiz attempts and phases (draft, submitted, reviewed) to prevent race conditions. Finally, math-text.ts adds support for rendering LaTeX formulas in quiz text using KaTeX, handling both explicit delimiters and embedded math.

lib/quiz · high confidence

The generation interface has been restructured with a new \GenerationToolbar\ and \MediaPopover\ that consolidate controls for web search, document uploads, and media generation (image, video, TTS, ASR) into a single, tabbed popover. Users can now select specific providers and models for each media type directly from the toolbar, with automatic filtering of unavailable or unconfigured options. The \OutlinesEditor\ has been enhanced to support interactive scene types (quiz, interactive, PBL) with distinct visual themes, drag-and-drop reordering, and streaming-aware auto-scrolling. Legacy progress indicators have been removed in favor of these integrated, real-time editing experiences.

components/generation · high confidence

The ActionsBar component has been refactored into a horizontal, film-strip-style timeline that serves as the primary interface for editing scene playback actions. Users can now insert, reorder, and delete actions—including speech lines, spotlights, lasers, and discussions—directly within the timeline. Speech clips support inline text editing, while element-bound cues (spotlights and lasers) allow users to click the cue to select a target element on the slide canvas. Hovering over a cue provides a live preview of its effect on the canvas, and the interface now correctly distinguishes between laser and spotlight effects. The timeline also enforces business rules, such as allowing only one discussion action per scene and ensuring it remains at the end of the sequence.

components/edit/ActionsBar · high confidence

The agent profile generation API now accepts detailed voice configuration data, including \availableVoices\ and a global \narratorVoice\, allowing the system to assign specific TTS voices to agents and the narrator. The logic for resolving the LLM model has been extracted into a dedicated \resolveModelFromRequest\ utility, which handles model selection and thinking configuration more robustly than the previous header-based approach. Additionally, the request schema has been updated to use \languageDirective\ instead of \language\, and the hardcoded color palette has been replaced with a centralized constant.

app/api/generate/agent-profiles · high confidence

The generation preview page has been restructured to improve maintainability and expand capabilities. The main page component was split into smaller modules, moving step definitions, session state types, and visualizers into dedicated files (types.ts, visualizers.tsx, vocational-mode.ts). This refactor introduces support for analyzing audio and video materials alongside PDFs, with specific UI visualizers for PDF scanning and web search results. It also adds vocational mode gating for procedural content generation and integrates document bundle validation for upload limits. Additionally, the layout was simplified to remove unnecessary wrapper logic, and retry options for foreground scene generation were extracted for better configuration management.

app/generation-preview · high confidence

The verify-model API endpoint now uses a centralized \resolveModel\ function to handle provider configuration and model string parsing, replacing the previous inline logic. Additionally, the actual connectivity test is performed via a new \callLLM\ wrapper instead of the direct \generateText\ call, allowing for better provider-specific handling and consistent logging of the model name on failure.

app/api/verify-model · high confidence

The scene actions API route has been updated to replace the previous manual header-based model configuration with a centralized \resolveModelFromRequest\ function, which now handles model selection and thinking configuration. Additionally, the route now imports generation logic from the \@openmaic/generation\ package instead of the local \lib/generation\ directory, and explicitly normalizes legacy PBL content structures before processing. Error logging has also been enhanced to include the specific outline title and resolved model string, and errors are now returned using a dedicated \llmApiError\ helper.

app/api/generate/scene-actions · high confidence

The Roundtable component has been significantly refactored to support a new presentation mode and improved audio feedback. A new \AudioIndicator\ component provides visual feedback for audio states (idle, generating, playing) using animated bars. The main component now integrates a \PresentationSpeechOverlay\ for displaying speech bubbles in presentation mode, handling collapsed/expanded states and playback controls. New props have been added to support discussion pause/resume, soft-closing grace windows, and element references. The component also now imports from updated paths for the Canvas toolbar and Proactive card, and includes new keyboard shortcut support and TTS-related props.

components/roundtable · high confidence

The scene content API has been refactored to support optional per-stage LLM model routing, allowing specific models to be selected for different generation stages rather than relying on a single global model. Additionally, the handling of vision-based inputs has been improved: image assets are now pre-resolved to concrete data URLs before being passed to the LLM, ensuring byte-identical prompts across different transport modes and preventing issues with unresolvable asset IDs. The API also now accepts optional \languageDirective\ and \requirements\ fields in the request body, and enforces a zero-retry policy (\maxRetries: 0\) for LLM calls within this route to prevent indefinite hanging on transient failures.

app/api/generate/scene-content · high confidence

The transcription and video provider verification endpoints now prioritize server-configured providers over client selections, allowing administrators to disable specific backends or pin models that clients cannot override. For any client-supplied base URL, strict SSRF validation is enforced to prevent unsafe network targets, and API keys are ignored for managed providers to ensure credential security. Additionally, model resolution now supports server-pinned defaults, and error logging has been enhanced to include the resolved provider and model identifiers for better troubleshooting.

app/api/transcription · high confidence

The image and video generation APIs now enforce server-side provider configuration, meaning the provider, API key, and base URL are determined by the server administrator rather than client headers. Clients can no longer override the provider, key, or base URL for managed providers, and requests to disabled providers are rejected. Additionally, client-supplied base URLs are validated against SSRF attacks, and generation usage is now recorded for billing and analytics. The image generation endpoint's timeout has also been increased to 300 seconds to accommodate longer workflows.

app/api/generate/image · high confidence

The image provider verification endpoint now enforces server-side configuration precedence, ignoring client-supplied API keys and base URLs for providers marked as server-managed. It introduces SSRF protection by validating client-provided base URLs before use and adds a 30-second execution timeout to prevent stalled requests. Additionally, the endpoint now validates that required models are configured for providers that support them, returning a specific error if missing.

app/api/verify-image-provider · high confidence

The Settings page has been significantly reorganized to support new capabilities and improve maintainability. New dedicated panels have been added: a Token Plan Settings panel for one-click configuration of provider presets, a Usage Dashboard for visualizing consumption across LLM, image, video, TTS, and ASR modalities, a Skill Settings panel for managing built-in and user-created agent skills, and an Add Audio Provider dialog for configuring custom TTS/ASR endpoints. Additionally, a new cache-clearing workflow handles deferred asset-pool deletations gracefully. To support this new structure, the legacy monolithic components \audio-settings.tsx\ and \model-selector.tsx\ have been removed, and the \add-provider-dialog.tsx\ has been refactored to use modern React patterns and i18n hooks.

components/settings · high confidence

The configuration files in the \configs/\ directory (including animation, chart, element, font, hotkey, image-clip, latex, lines, mime, shapes, storage, symbol, and theme) now import their type definitions from the \@openmaic/dsl\ package instead of the local \@/lib/types/slides\ module. This change aligns the editor's configuration layer with the centralized DSL package. Additionally, all files have been reformatted to comply with Prettier standards, including adding missing semicolons, standardizing quote styles, and ensuring consistent array/object formatting.

configs · high confidence

The stream buffer API has been updated to better coordinate with text-to-speech (TTS) and action effects. The \onActionReady\ callback now receives an \AbortSignal\, and a new \waitForCurrentAction\ method allows callers to pause until an action's side effects are complete. Additionally, the buffer introduces \shouldHoldAfterReveal\ and \onSegmentSealed\ callbacks, along with internal state tracking (\\_holdingForTTS\), enabling the presentation layer to hold on a revealed text segment until TTS playback finishes. The \flush\ method is now asynchronous, ensuring that all pending actions and text reveals are fully processed before resolving.

lib/buffer · high confidence

The \components/ui\ library has been updated to enforce consistent code formatting (single quotes, semicolons) and improve accessibility and portability. New components \AvatarDisplay\ and \CircularProgress\ have been added to support avatar rendering and determinate progress indicators. The \FloatingLayerOwner\ context and utilities have been introduced to manage dismissal logic for portaled UI surfaces. Additionally, \AlertDialog\ now supports a custom \container\ prop for portal mounting, and \Combobox\ has been migrated from \@radix-ui/react-combobox\ to \@base-ui/react\.

components/ui · high confidence

Image and video elements now use a shared \useResolvedImageSrc\ and \useResolvedVideoMedia\ hook to consistently resolve generated media placeholders, providing clearer feedback for pending, disabled, and failed states with retry capabilities. The code element component has been introduced with line-by-line typing animations and syntax highlighting via Shiki. Chart elements now include defensive checks to prevent crashes on malformed data and display axis labels more reliably. Additionally, all element type imports have been migrated from the local \@/lib/types/slides\ module to the \@openmaic/dsl\ package.

components/slide-renderer/components/element · high confidence

The AI library now provides consistent, configurable reasoning capabilities for OpenAI-compatible providers (such as DeepSeek, Kimi, GLM, and Qwen) alongside native providers. A new thinking configuration system normalizes effort, level, and budget settings across all models, while a new streaming middleware rewrites provider-specific reasoning streams (like \reasoning\_content\) into a standard format so they appear correctly in the UI. Additionally, the library adds support for the Azure OpenAI provider and introduces model ID aliases to simplify model lookups.

lib/ai · high confidence

The \useASRAvailable\ hook now provides a single source of truth for speech recognition availability, combining the global toggle, provider configuration (API keys, server-side disable flags, and model presence), and browser Web Speech API support to uniformly gate the \SpeechButton\. The \useAudioRecorder\ hook has been updated to enforce this availability check locally before invoking the Web Speech API, supports continuous recognition mode, and includes a synchronous lock to prevent rapid re-entry issues during recording. Additionally, the \useBrowserASR\ hook now properly cleans up the SpeechRecognition instance on unmount to prevent memory leaks and microphone hold-ups.

lib/hooks · high confidence

The stage header controls have been extracted into a shared component to provide a consistent set of global actions (language, theme, settings, export) across both playback and Pro edit modes, ensuring stable positioning and layout when switching between them. The scene sidebar now renders detailed, type-specific thumbnails for slides, quizzes, interactive content, and PBL scenes, replacing previous icon-only or stub placeholders to improve visual clarity. Additionally, a new video export dialog has been introduced to replace the previous dropdown menu, offering a stable interface for configuring resolution, FPS, and quality, and supporting both server-side MP4 rendering and local ZIP downloads.

components/stage · high confidence

The web search API has been upgraded from a single Tavily backend to a multi-provider architecture (including Brave, Baidu, SearXNG, Exa, and Claude), allowing operators to configure the default provider and enforce server-side precedence over client selections. The route now supports context-aware query rewriting, where uploaded PDF text can be used to refine search queries via an LLM, and introduces specific handling for provider requirements such as API keys and base URLs, while ensuring disabled providers are blocked regardless of client input.

app/api/web-search · high confidence

Agents can now add and edit code blocks on the whiteboard using the new wb\_draw\_code and wb\_edit\_code actions, with syntax highlighting and file-name support. The orchestration graph no longer enforces a maxTurns cap; instead, each request runs a single director-to-agent cycle, with the client serializing multiple requests to drive multi-agent discussions. Prompt building has migrated to file-based templates, and the parser now suppresses structured-output residue to prevent raw JSON from leaking into chat bubbles.

lib/orchestration · high confidence

The whiteboard component now includes a history feature that automatically saves snapshots before clearing and allows users to restore previous states via a new dropdown panel. A 'Reset View' button has been added to revert pan and zoom changes, and the canvas now supports runtime projection updates for more accurate synchronization with the stage. These changes improve the user's ability to manage whiteboard content and maintain visual consistency during presentations.

components/whiteboard · high confidence

The chat API route now delegates API key, base URL, and provider configuration to a centralized \resolveModel\ function, ensuring consistent credential handling and supporting per-stage model routing and thinking configurations. Additionally, error logging has been improved to include specific context such as the model name, message count, and agent IDs, aiding in faster debugging of chat failures.

app/api/chat · high confidence

The HTML export logic in the parser now correctly preserves all attributes on an element even when the style attribute is present but empty. Previously, an empty style attribute caused the \reduce\ function in \stringify.ts\ to return an empty string, which inadvertently dropped all previously accumulated sibling attributes from the output. This fix ensures that attributes like \class\ or \id\ are retained in the generated HTML alongside an empty style attribute.

lib/export/html-parser · high confidence

Corrects a bug in the MathML-to-OMML parser where the code incorrectly attempted to index the \includes\ method of the \textContainerNames\ array. This change ensures that the check for whether a node name is a text container executes correctly, preventing runtime errors during parsing.

packages/mathml2omml · high confidence

Resolves two issues in the materials API: sanitizes the owner ID in the byte-store key to prevent Windows path errors caused by colons, and resolves generic Office MIME types (application/vnd.ms-office) by falling back to filename extensions for accurate content-type detection.

app/api/materials · high confidence

The PDF parsing API now validates client-supplied base URLs against SSRF attacks before use and prevents clients from overriding server-configured provider credentials or endpoints. Additionally, error logs now include the provider ID and file name for better debugging, and the underlying PDF extraction logic has been routed through a new document extraction boundary.

app/api/parse-pdf · high confidence

The classroom API now enforces stricter security and data integrity measures. Classroom IDs are exclusively generated server-side to prevent users from specifying or overwriting existing IDs, with collision handling via bounded retries. All incoming scene content is sanitized before storage to restrict HTML to a safe formatting vocabulary, and the GET endpoint applies the same sanitization to existing stored content to clean previously unsanitized data at serve time. Input validation is also hardened to reject malformed stage and scene structures early.

app/api/classroom · high confidence

The media proxy API now enforces stricter security and stability controls. It resolves DNS only once and pins connections to the validated IP address to prevent DNS rebinding attacks, and it re-validates the URL at every redirect hop to stop redirect-based SSRF. Additionally, the proxy now limits responses to 25 MiB and caps redirects at five hops to prevent resource exhaustion.

app/api/proxy-media · high confidence

Added API test coverage for classroom media, generation, and provider verification; Added Playwright e2e page objects for classroom, generation preview, and home; Added Playwright e2e test fixtures for mocking API and seeding interactive state; Added comprehensive test coverage for AI provider integrations and reasoning logic; Added comprehensive test coverage for the media asset pool and generation pipeline; Added comprehensive test coverage for the video-export pipeline; Added contract tests for CI video-export and publish workflows; Added contract tests for agent session and asset storage; Added e2e test fixtures for scene generation and settings persistence; Added i18n regression tests for editor, generation, and TTS UI strings; Added provider neutrality guard tests; Added security tests for iframe sandbox configurations; Added server-side test coverage for access control, audio SSRF hardening, and agent generation; Added snapshot tests for soft edge image rendering; Added test coverage for PBL v2 legacy migration, runtime operations, and UI components; Added test coverage for chart rendering logic and ECharts integration; Added test coverage for configuration, settings persistence, and editor registry logic; Added test coverage for document parsing, extraction, and media handling; Added test coverage for quiz grading, math rendering, persistence, and runtime state; Added test coverage for render-service core components; Added test coverage for renderer components and utilities; Added test coverage for server-backed asset persistence and lifecycle; Added test coverage for slide renderer components and media resolution logic; Added test coverage for the OpenMAIC importer pipeline; Added test coverage for the generation module; Added test coverage for whiteboard runtime and legacy import logic; Added test for editor package manifest metadata; Added tests for ActionEngine LaTeX rendering, video media resolution, and widget actions; Added tests for BaseLineElement marker ID stability; Added tests for BaseVideoElement rendering behavior; Added tests for ClawHub version checking and OpenMAIC skill publishing scripts; Added tests for GenUI viewport logic and interactive iframe handling; Added tests for InteractiveModeButton visual and accessibility contract; Added tests for LLM entry-point lint guard, quiz grading logic, and test environment isolation; Added tests for LaTeX element font-metric re-measurement; Added tests for Pi agent runtime, tooling, and evidence resolution; Added tests for StreamBuffer ordering and lecture auto-resume logic; Added tests for action-level navigation, cursor persistence, and stage deletion cleanup; Added tests for agent client regeneration and outline resolution; Added tests for agent runtime tool timeouts, streaming contracts, and child agent execution; Added tests for audio and table renderer elements; Added tests for brand configuration, HTML editing, and iframe utilities; Added tests for chat agent loop, quiz results, and UI components; Added tests for chat session lifecycle and state management; Added tests for choreography playback, animation descriptors, and timing logic; Added tests for classroom ZIP import media handling and server-backed persistence; Added tests for classroom agent selection, fetch outcomes, and media restoration; Added tests for concurrency utilities, storage layers, and alignment logic; Added tests for conversation summarization, LaTeX guardrails, and whiteboard conflict detection; Added tests for evaluation harness components; Added tests for image element rendering and filter handling; Added tests for interactive state sampling and observation parsing; Added tests for omitUndefinedObjectMembers persistence utility; Added tests for orchestration agent registry, state context, and whiteboard summarizers; Added tests for prompt loader, conditional media, and procedural skill contracts; Added tests for quiz and slide editor surfaces; Added tests for runtime storage, chat cutover, and whiteboard operations; Added tests for scene generation, TTS, and media hooks; Added tests for settings store persistence, provider selection, and UI components; Added tests for slide element selection, playback renderer overlays, and whiteboard projection recovery; Added tests for text element rendering logic; Added tests for the Agent Workbench; Added tests for the RAG document ingestion and lexical indexing foundation; Added tests for the document store configuration, migration, and persistence layers; Added tests for web search provider integrations and routing; Added unit tests for audio subsystem components; Added unit tests for the edit workspace components and logic; Expanded end-to-end test coverage for core user flows and edge cases; Expanded test coverage for agent runtime core components; Expanded test coverage for classroom ZIP export and narration script generation; New orchestration evaluation suite for director routing and answer-content quality.

This release bumps the main application version to 1.0.3 and enforces a Node.js engine floor of \>=22.19.0. It introduces several new workspace packages—@openmaic/dsl, @openmaic/editor, @openmaic/generation, @openmaic/importer, @openmaic/renderer, and @openmaic/storage—along with a new isolated render-service for MP4 exports. The dependency graph is updated to include AI SDK providers (Amazon Bedrock, Azure), Alibaba Cloud DocMind, AWS S3 clients, and various UI/font libraries, while upgrading core dependencies like Next.js to 16.3.3, React to 19.2.3, and Tailwind CSS to 4.x.

(dependencies) · high confidence

The public/vendor/gsap.min.js file has been updated to GSAP version 3.15.0. This change replaces the previous version of the GreenSock Animation Platform library, which may affect animation performance, timing precision, and compatibility with existing GSAP-dependent code in the video-export feature.

public/vendor · high confidence

The AI elements components (artifact, canvas, chain-of-thought, checkpoint, code-block, confirmation, connection, context, controls, conversation, edge, image, inline-citation, loader, message, model-selector) have been reformatted to use single quotes for strings and consistent indentation, aligning with the project's Prettier configuration. This change improves code consistency and readability without altering any component behavior or functionality.

components/ai-elements · 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 53.

• Code Health 61
• Architecture 69
• Maturity 70
• Readiness 55
• Security 64
• Accessibility 46

• 300 commits — 167 feature/other, 133 fixes

• packages/@openmaic — 60 commits
• (root) — 32 commits
• lib/i18n — 31 commits
• lib/server — 13 commits
• render-service/src — 10 commits
• .github/workflows — 7 commits
• app/api — 7 commits
• lib/audio — 7 commits
• tests/lib — 7 commits
• tests/server — 7 commits
• lib/media — 6 commits
• lib/pbl — 6 commits
• packages/docs — 6 commits
• lib/ai — 5 commits
• lib/utils — 5 commits
• render-service/test — 5 commits
• tests/media — 5 commits
• lib/document — 4 commits
• tests/store — 4 commits
• components/edit — 3 commits

• fix: Fix Traditional Chinese translations in importer index.html (#1127)
• fix: fix image storage IDs containing underscores (#918)
• fix: fix(access-code): expire tokens server-side and throttle verification behind a trusted proxy (#1513)
• fix: fix(access-code): refetch server providers after access code is accepted (#1081)
• fix: fix(agent): bound import_pptx parse with size cap and timeout (#1268) (#1269)
• fix: fix(agent): harden shared Pi transport contracts (#1108)
• fix: fix(agent): preserve generate_scene failure causes (#1316)
• fix: fix(agent-runtime): allow one owner material to be bound to multiple sessions (#1500)
• fix: fix(ai): add opt-in streaming chat compatibility (#990)
• fix: fix(ai): let LLM calls outlive undici's 300s headers timeout (#1404)
• fix: fix(ai): omit zero SiliconFlow thinking budget (#1035)
• fix: fix(ai): share thinking context across bundle evaluations (#1378)
• fix: fix(api): validate pdfContent input (#1578)
• fix: fix(asr): bypass AI SDK for custom providers to handle extra response… (#1283)
• fix: fix(audio): play discussion lines through one reused media element (#1610)
• fix: fix(audio): rebuild platform FormData bodies for the undici transport (#1580)
• fix: fix(audio): resolve CDN-backed narration consistently (#1521)
• fix: fix(audio): reuse one narration element so mobile playback survives the first segment (#1477)
• fix: fix(audio): validate redirects and pin connections on provider requests (#1514)
• fix: fix(build): scope Next typecheck to production sources (#1179)
• …and 280 more

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

THU-MAIC/OpenMAIC 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.