Skip to content
CAI
Software that uses CAICheck a score

THU-MAIC/OpenMAIC

44.2

Weak · 7 November 2026

403.1k

lines of production code

TypeScript

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add MinerU Cloud and AliDocMind PDF parsing providers

The PDF extraction library now supports two new providers: MinerU Cloud (a managed API service) and AliDocMind (Aliyun's document parsing service). This introduces new client implementations for both services, a shared result parser for MinerU outputs, and updates to the provider registry and configuration types to handle their specific authentication models (API key for MinerU Cloud, AccessKey pair for AliDocMind). The existing self-hosted MinerU and unpdf providers remain available, and the unpdf extractor now supports a text-only mode to skip image extraction.

lib/pdf · high confidence

Add document lexical retrieval foundation

Introduces the core infrastructure for document-based lexical search within the RAG system. This includes a new chunking engine (\lib/rag/chunking\) that splits document blocks into grapheme-aware chunks using a configurable policy, an ingestion pipeline (\lib/rag/ingest\) that transforms documents and generates these chunks with full lineage tracking, and an in-memory lexical index (\lib/rag/providers/in-memory-lexical-index\) that supports tokenized text querying, metadata filtering, and scoped retrieval for workspaces and courses.

lib/rag · high confidence

Added PPTX importer source and debugging scripts

The @openmaic/importer package now includes the source code for the 'src1' PPTX-to-JSON parser (including modules for alignment, animation, borders, charts, colors, fills, fonts, math, and positioning) and new CLI scripts for debugging and testing. The \extract-pptx-structure.js\ script allows users to inspect the internal file tree of a PPTX file and optionally extract its contents, while \transvert.js\ and \transvert.ts\ provide direct testing interfaces for the 'src1' and 'pro' parsing implementations respectively.

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

Agent skill management API endpoints

New API routes have been added to manage agent skills, allowing users to list, upload, retrieve, and delete their own skills. The \/api/agent/skills\ endpoint supports listing available skills and uploading new ones via ZIP or Markdown files, while \/api/agent/skills/\[id\]\ enables fetching or deleting specific user-owned skills. Additionally, \/api/skills/\[id\]\ provides a way to download skills (including built-in and OpenMAIC skills) as ZIP archives. These endpoints are gated by the \isAgentRuntimeConfigured\ feature flag and require owner authentication.

app/api/agent/skills, app/api/skills · high confidence

Build-time font generation for slides and KaTeX formulas

Added build scripts to automatically generate CSS and TypeScript assets for fonts, ensuring reliable rendering in exported slides. The new \generate-fonts-css.mjs\ script creates \fonts.css\ from \fonts.config.mjs\ to support self-hosted Chinese fonts for PPTX imports, while \generate-katex-fonts.mjs\ inlines KaTeX web fonts as data URLs into \src/snapshot/katex-fonts-embed.ts\. This pre-bundling ensures that mathematical formulas render correctly in PNG snapshots by avoiding runtime CSSOM access issues with cross-origin stylesheets.

packages/@openmaic/renderer/scripts · high confidence

Classroom ZIP and PPTX import capabilities

Users can now import content from classroom ZIP archives and Microsoft PowerPoint (PPTX) files. The classroom ZIP importer handles media assets by persisting them to the server asset pool and rewriting internal references to ensure correct playback and display. The PPTX importer leverages a dynamically loaded external parser to convert slides into the application's internal format, supporting optional media uploads to keep assets persistent across sessions.

lib/import · high confidence

Code elements now feature line-by-line typing animations

The CodeElement component in the slide renderer now supports a line-by-line entrance animation. When enabled, code blocks appear with a typing effect that reveals content progressively, complete with a blinking cursor and human-like typing easing, rather than appearing all at once.

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

Course folder grouping in the discovery library

Users can now organize courses into folders within the discovery library. This update introduces folder cards that display stacked thumbnails of member courses, support drag-and-drop reorganization, and allow renaming or deletion. A new dialog handles folder creation with name validation, and a context menu on course tiles enables quick moves to existing folders or creation of new ones. Skeleton loading states have been added to ensure a smooth visual transition while folder and course data loads.

components/discovery · high confidence

Deployment-wide usage tracking and aggregation API

Added a new GET /api/usage endpoint that aggregates deployment-wide usage logs by model, day, and modality, exposing totals for requests and LLM tokens. This relies on a new library module (lib/usage/normalize.ts) that normalizes AI SDK v6 usage data into a consistent four-class token shape (input, output, cache read, cache creation) plus reasoning tokens, ensuring partial or missing usage objects are handled safely. The API supports optional month filtering and returns sorted aggregates for consumption by a usage dashboard.

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

Deterministic static interactive HTML export with precise effect rendering

The video export now generates self-contained, deterministic static HTML compositions (Hyperframes) that faithfully reproduce visual effects like spotlights and laser pointers using precise geometry and finite, paused GSAP timelines. This change ensures that exported content renders identically across environments by eliminating non-deterministic elements like infinite repeats or wall-clock dependencies, and includes support for specific font handling and localized labels for Quiz and PBL cover cards.

lib/video-export/emit-hyperframes · high confidence

Export classrooms as a single offline HTML file with a ZIP fallback

Classrooms can now be exported as a self-contained HTML file that plays slides, interactive scenes, quizzes, and PBL briefings offline without requiring a server. The export embeds the precompiled player, the classroom manifest, and media (narration audio, video, and images) as base64 data blocks, and enforces a strict Content Security Policy to prevent external network access. For large classrooms that exceed the 400 MB single-file limit, the system automatically falls back to a ZIP archive containing \classroom.html\ alongside its media folders, ensuring reliable playback even when a single file would be too large.

lib/export/standalone-html · high confidence

Initial release of the @openmaic/importer package

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

Interactive courseware observation and widget type definitions

The platform now supports referencing interactive courseware elements in chat. This change introduces a new observation system (lib/interactive) that captures and validates the state of embedded HTML components via an iframe bridge, enforcing strict size and depth limits to prevent crashes. It also adds new type definitions for interactive references (SlideElementReference, InteractiveComponentReference, WhiteboardElementReference) and expands the chat session model with soft-closing states and director compaction traces. Additionally, the lib/types folder now defines configuration schemas for new Ultra Interaction Mode widgets (Simulation, Diagram, Code, Game, 3D Visualization, Procedural Skill) and introduces a FolderRecord type for organizing courses. The legacy PBL v1 generation engine and its associated types have been removed in favor of the v2 path.

lib/types · high confidence

Introduce @openmaic/dsl as the zero-dependency contract keystone

The new @openmaic/dsl package establishes the pure, zero-runtime-dependency contract for the MAIC SDK, centralizing the slide object model, lesson skeleton, and playback verb definitions. It provides build-time JSON Schema artifacts for cross-language validation, pure in-process validators, and a normalizer that repairs documents by filling required-field defaults and deriving geometry. The package also introduces a versioned migration registry to handle serialized contract changes and a standardized asset manifest enumeration to track document references, ensuring that dependent packages like the renderer and importer can rely on a consistent, dependency-free spec.

packages/@openmaic/dsl · high confidence

Introduce @openmaic/editor package for composable slide editing

This change introduces the new @openmaic/editor package, providing a composable slide-editing surface for OpenMAIC. The package exposes a core transaction engine (with undo/redo history), a React-based editable canvas with interaction gestures (drag, resize, rotate, marquee selection), and a UI layer with toolbars and context menus. It integrates with @openmaic/renderer for visual rendering and @openic/dsl for data contracts, allowing host applications to control document state, selection, and persistence while leveraging built-in element adapters, insertion defaults, and clipboard behavior.

packages/@openmaic/editor · high confidence

Introduce @openmaic/renderer as a standalone, read-only slide rendering package

The read-only canvas component has been extracted from the main OpenMAIC application into a new, standalone npm package (\@openmaic/renderer\). This package allows any React + Tailwind 4 project to install and render PPTist-style slide JSON without the full editor suite. It provides a \SlideCanvas\ component with props for scaling, background overrides, and optional playback effects (laser, spotlight, highlight, zoom). The renderer includes built-in support for CJK fonts via a self-hosted CDN, media injection slots for custom image/video handling, and granular element exports for custom layouts. Editing capabilities are explicitly excluded from this package and moved to the separate \@openmaic/editor\ package.

packages/@openmaic/renderer · high confidence

Introduce OpenMAIC 1.0.0 workbench with Pro workspace and editing dock

This release introduces the OpenMAIC 1.0.0 workbench, establishing a dedicated \/workspace\ route for the Pro workspace and a backward-compatible \/workbench/new\ bridge to handle legacy launch links and rolling deployments. The workspace features a new bottom editing dock that includes a global edit bar with a roster dialog, a canvas pager, and an element-reference lasso tool for selecting slide elements. The application is now branded as OpenMAIC with a static configuration, and the site header includes a new theme toggle for switching between light, dark, and system modes.

(repo-wide) · high confidence

Introduce PBL v2 agent architecture with dedicated Instructor, Planner, Evaluator, and Simulator components

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 help levels based on learner proficiency. The Planner agent (\planner.ts\) has been refactored to use a single-pass agentic loop for generating project structures. A new Evaluator agent (\evaluator.ts\) handles streaming feedback for tasks, milestones, and final completions, while a Simulator agent (\simulator.ts\) enables in-character role-play scenarios with dedicated context management. These components replace the previous v1 generation and teaching paths.

lib/pbl/v2/agents · high confidence

Introduce PBL v2 runtime API endpoints for instructor, simulator, evaluation, and task management

This change adds five new server-side API routes under /api/pbl/v2 to support the PBL v2 runtime. The /instructor and /simulator endpoints stream AI-driven interactions (instructing and roleplay) back to the client via Server-Sent Events (SSE), handling model resolution and project state patches. The /evaluate endpoint provides a unified SSE entry point for task, milestone, and final project evaluations. The /open-task endpoint manages the initial greeting and setup phases, including pre-play quiz recalibration. Finally, the /task/update endpoint handles pure state mutations for microtask progression (start, complete, handover) and scenario-specific stage transitions without involving the LLM.

app/api/pbl/v2 · high confidence

Introduce PBL v2 workspace UI with multi-agent chat, streaming, and evaluation cards

The PBL v2 workspace now features a new React-based UI in \components/scene-renderers/pbl/v2\. This includes a multi-agent tab system (\agent-tabs.tsx\) that routes to a dedicated chat panel (\chat.tsx\) for each agent, supporting live streaming of instructor responses and external streams. The workspace displays structured evaluation feedback via new card components: \TaskEvaluationCard\ for immediate task feedback, \MilestoneCard\ for stage reflections with handover gating, and a \CompletionCtaCard\ that prompts learners to view the final report. A dedicated \completion.tsx\ page presents a summary combining LLM narrative and deterministic stats. Supporting utilities handle project state patching from SSE events (\apply-instructor-event.ts\), hero page scaling (\fit-scale.ts\), and layout tracking (\host-rect.ts\).

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

Introduce PDF provider verification endpoint with SSRF protections

Adds a new API endpoint at /api/verify-pdf-provider to validate PDF parsing service connectivity and credentials. The endpoint supports verifying saved providers, MinerU Cloud, and AliDocMind (including strict endpoint allowlisting for client-supplied AliDocMind URLs). It enforces server-managed configuration for admin-owned providers, prevents credential forwarding via client-supplied base URLs, and hardens against SSRF by rejecting redirects and validating DNS resolution before connection.

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

Introduce Pi Director Chat API and Whiteboard Visibility endpoints

This change introduces the core server-side API for the Pi classroom runtime. The new \app/api/chat/pi/route.ts\ endpoint implements the Pi Director loop, handling multi-agent orchestration, model resolution, and validation of classroom agent configurations. It also adds support for courseware references, including specific handling for whiteboard element references and interactive state evidence. Additionally, a new \app/api/chat/pi/whiteboard-visibility/route.ts\ endpoint allows the system to settle whiteboard visibility queries (open/closed) for specific learners, ensuring that only the request owner can update the visibility state.

app/api/chat/pi · high confidence

Introduce RuntimeStore for learner session and record persistence

The storage package now includes a new RuntimeStore interface and three concrete backends to manage learner runtime data (sessions and append-only records). The browser backend persists data to IndexedDB, the HTTP backend communicates with a server via a JSON API, and the PostgreSQL backend stores data in a relational database. All implementations enforce strict payload validation (rejecting non-JSON-safe values like NUL characters or unpaired surrogates) and handle schema migrations automatically, providing a unified way to store chat and quiz data locally or remotely.

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

Introduce agent session runtime API endpoints

This change adds the core API routes for the new agent session runtime, enabling users to create sessions, send messages, stream events via Server-Sent Events (SSE), cancel running sessions, and manage session titles. The implementation includes durable event replay with Last-Event-ID support, owner-based access control for all session operations, and integration with material bindings and skill inference for session creation.

app/api/agent/sessions · high confidence

Introduce durable PostgreSQL backend for agent sessions

The agent session storage layer now uses a new PostgreSQL implementation (pg.ts) with a defined schema (sessions, events, entries, owner events, URLs) and strict type contracts (types.ts). This backend supports session lifecycle management (queued, running, succeeded, failed, cancelled), lease-based concurrency control, and append-only event/entry trees. It includes data integrity safeguards such as JSONB sanitization for NUL/surrogate characters, descriptive text sanitization, and pruning of redundant intermediate message frames, ensuring reliable persistence of conversation data and titles.

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

Introduce durable session-scoped material storage backend

Added a new PostgreSQL-backed storage layer for session-scoped materials, enabling the system to persist metadata for content such as web pages, transcripts, and extracted assets within a session. This change introduces the \agent\_session\_materials\ table schema, type definitions for material kinds and extraction states, and the \PgAgentSessionMaterialStore\ implementation to manage these records durably.

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

Introduce extensible web fetch provider registry with built-in and hosted options

The web-fetch module now supports a pluggable provider registry, allowing users to choose between the local built-in reader and hosted third-party services (DeepSeek, Firecrawl, and Kimi) for fetching and extracting web content. The built-in provider handles HTML, text, and PDF extraction locally using pinned DNS and strict timeouts, while hosted providers offload the extraction to external APIs, requiring API keys and supporting configurable base URLs and proxies. This change adds the core infrastructure (types, registry, and abort handling) and the specific implementations for these four providers, enabling users to select the most suitable extraction method for their needs.

lib/web-fetch · high confidence

Introduce in-editor classroom agent roster management

Users can now author and manage the classroom agent roster directly within the editor via a new dialog accessible from the edit dock's global bar. This feature introduces a single source of truth for stage-level agent configurations, allowing users to add, remove, rename, and reorder AI classmates, edit their personas, and pick avatars. The roster editor supports undo/redo operations and persists changes through a dedicated pending-change scheduler, ensuring edits are saved independently of the main course save cycle.

components/edit/AgentsView · high confidence

Introduce scoped key-value storage with Zustand persistence adapter

The @openmaic/storage package now provides a key-value store abstraction that distinguishes between 'account' and 'device' scopes. 'Account' data is synced to a server via a new HTTP client, while 'device' data remains strictly local, enforced by type and runtime checks to prevent accidental network transmission. This includes a browser-based backend using localStorage and a Zustand persist adapter that allows application state to be stored in this scoped KV system, ensuring that local UI preferences stay on the device while user settings can be synchronized.

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

Introduce server-backed persistence routes for asset handling and stage metadata

This change adds new API route handlers in the persistence layer to support server-backed asset storage and per-viewer stage metadata. The new \/api/persistence/\[...path\]\ route implements the core asset lifecycle, including indirect byte egress via signed URLs, learner key derivation, and learner merge operations through owner claims, while ensuring binary response bodies are handled correctly. The new \/api/stage-meta/\[stageId\]\ route provides a fail-closed, unauthenticated-friendly endpoint that returns tenancy and ownership signals (such as \isOwner\ and \isPublic\) for a given stage, allowing clients to distinguish between deleted, public, and private content without exposing owner identities. These routes are gated by the server persistence configuration, ensuring they only operate when the backend is available.

app/api/persistence · high confidence

Introduces Pro-mode slide editing and agent roster management

The editor now supports a Pro-mode slide editing surface, enabling users to create, duplicate, and manage slides with full undo/redo history and element-level operations (add, update, delete, reorder). A new agent roster system allows in-editor authoring of classroom agents, including adding, updating, and deleting agents with role-based constraints (e.g., preventing deletion of the last teacher). Content validation is introduced to surface issues like empty speech lines or unbound cues, and a recycle bin enables undoing slide deletions via toast notifications. The editor also supports multi-tab editing by removing cross-tab locks, and assets are now allocated through a registry for consistent management. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 1 commit (1 fix) fixing e2e, lib/edit; Shape geometry validation and SVG export fixes; Editor now detects legacy speech audio issues alongside content validation.

lib/edit · low confidence · unverified

Introduces a new Pi agent runtime with context compaction, interactive state evidence, and whiteboard visibility management

This change adds a new runtime layer for the Pi agent in the chat interface, introducing a 'native' child runtime mode alongside the existing 'legacy' mode. It implements context compaction to manage token limits during multi-agent loops, validates and attaches interactive state evidence from classroom scenes, and manages whiteboard visibility queries. The update also includes configuration resolution for agent turns and actions, prompt building for the director and child agents, and element reference handling for static and interactive content.

lib/chat/pi · high confidence

Introduces a pure, deterministic video-timeline compiler for classroom exports

The \lib/video-export\ module now provides a dedicated compiler that transforms classroom data into a \VideoTimeline\ intermediate representation (IR) using a chain of pure, synchronous passes. This architecture removes the need for FFmpeg, Chrome, or the DOM during compilation, allowing the export logic to run in Node.js and be unit-tested with simple in-memory stubs. The compiler handles scene normalization, timing resolution via injected probes, visual cover generation for Quizzes and PBLs, geometry-based effect placement, and asset planning. It also includes utilities for splitting narration into readable subtitle cues and serializing them to SRT/VTT formats, while recording first-class diagnostics for any degraded or unsupported scenes to ensure an auditable export report.

lib/video-export · high confidence

Introduces native classroom agent tools for web search, whiteboard editing, and scene context

The Pi agent runtime now includes a suite of new native tools that allow it to interact directly with the classroom environment and external data. Agents can perform web searches via \buildNativeWebSearchTool\ to retrieve auditable sources, read course scene evidence and interactive static text via \read\_scene\, and manage session flow using \close\_session\ and \cue\_user\. Additionally, agents can manipulate the whiteboard using \buildNativeWhiteboardTools\ (supporting shapes, charts, code, and text) and highlight specific elements with \buildNativeSpotlightTool\, all governed by strict parameter validation and authorization checks.

lib/chat/pi/tools · high confidence

Introduces site-level access code authentication and restructures component initialization

The application now supports site-level access code authentication, introducing an AccessCodeGuard that intercepts unauthenticated requests and an AccessCodeModal for users to enter their credentials. Upon successful authentication, the system automatically reloads the agent registry, model settings, and resumes legacy browser imports to ensure the workspace is fully configured. This change also replaces the previous AgentBar and AgentConfigPanel with a new LanguageSwitcher and dedicated initialization components (ModelSettingsInit, AgentRegistryInit) to handle settings and agent loading more robustly, while removing the legacy ServerProvidersInit and TtsConfigPopover in favor of a unified media configuration flow.

components · high confidence

Introduces the MAIC Editor v0 with a new edit-mode chrome and layout system

This change introduces the MAIC Editor v0, replacing the previous edit-mode implementation with a new chrome assembly. It adds a new \StageGrid\ layout shell that defines five named slots (top, left, right, bottom, center) to structure the editor interface, and a \ContainBox\ component that handles precise 16:9 aspect-ratio sizing and layout settling for the canvas. The \EditChromeRoot\ component now serves as the single mount point for edit mode, integrating the \SlideNavRail\, \EditDock\, and \HeaderControls\ while managing feature flags for the Pro mode and AI editor. Additionally, a \scene-timeline\ utility is added to determine narration timeline availability based on scene type and registered editor surfaces.

components/edit · high confidence

New API endpoint for serving classroom media with range-request support

A new API route at app/api/classroom-media/\[classroomId\]/\[...path\] has been added to serve media files stored in classroom directories. This endpoint supports HTTP range requests, enabling efficient 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.

app/api/classroom-media · high confidence

New API endpoint to poll classroom generation job status

Users can now check the status of a classroom generation task by sending a GET request to /api/generate-classroom/:jobId. This endpoint validates the job ID format, ensures the requester is the owner of the job, and returns the current state of the generation run along with its associated media assets. If the job is not found or the request is invalid, it returns a 404 or 400 error respectively; internal errors return a 500.

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

New API endpoint to probe and filter available chat models

A new POST endpoint at /api/provider/probe-models has been added to the provider API. This feature allows the client to discover which chat models are available on a configured base URL by querying the provider's /models endpoint. The endpoint supports using saved workspace provider credentials or raw keys (if allowed), and includes SSRF protection for the base URL and any custom models URL override. It automatically filters out non-chat models (such as TTS, ASR, embedding, and image models) and returns a clean list of chat model IDs along with ownership details. Error handling is standardized to provide user-friendly messages for issues like invalid API keys, redirects, or missing model endpoints, while keeping internal upstream details hidden from the client.

app/api/provider · high confidence

New API endpoints for claiming anonymous identity and binding legacy browser data

Two new server-side API routes have been added to handle identity migration. The \/api/identity/claim\ endpoint allows a signed-in user to claim data previously stored under an anonymous identity, moving it to their account and retiring the anonymous cookie. The \/api/identity/legacy-import-binding\ endpoint binds pre-server browser data to the current owner, ensuring that legacy imports are correctly associated with the authenticated user. Both endpoints enforce same-origin JSON requests and require server-side persistence configuration.

app/api/identity · high confidence

New Agent Bar with persistent voice selection and preview

The Agent Bar component has been introduced to manage agent-specific TTS settings, allowing users to select voices per agent and persist those choices across page reloads. It features a searchable popover for filtering available TTS providers and voices, along with a preview capability that plays audio samples directly from the client. The component also integrates with the settings store to maintain voice overrides and resolves voice options dynamically based on the agent's configuration.

components/agent · high confidence

New Course Model Config and Model Services settings panels

The Settings page now includes a restructured Course Model Config and Model Services area. The Course Model Config provides a visual, interactive map of the product's model pipeline, allowing users to see and edit which models are assigned to specific slots (such as chat, research, or content generation) with support for inheritance, locking, and inline thinking-intensity controls. The Model Services panel organizes provider management into dedicated tabs (providers, image, video, TTS, ASR, PDF, web search), enabling users to configure API keys, test connectivity, and manage service endpoints. This change introduces new UI components for model selection, service configuration, and visual diagramming to centralize model and provider management.

components/settings · high confidence

New DocumentStore backend with browser and server implementations

The storage layer now includes a new DocumentStore interface with two concrete backends: a browser-based implementation using IndexedDB (storing stages, scenes, and outlines in separate object stores) and a server-based implementation using PostgreSQL (storing data in JSONB columns with separate tables for stages, scenes, and outlines). Both backends normalize the document aggregate into per-entity rows on write and reassemble them on read, applying DSL version migrations. The browser backend validates scenes against configurable validators and handles IndexedDB transactions, while the server backend supports owner-scoped document access through a configurable ownership relation, folder organization, and asset reference tracking. A shared adapter handles the translation between the embedded document format and the normalized row structure.

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

New PBL v2 planner evaluation harness with A/B comparison viewer

Adds a dedicated evaluation harness for the PBL v2 planner that runs test cases through both the legacy loop-based planner and the new single-call planner, then scores the outputs using LLM-based judges for design quality and runtime completability. The harness writes structured results to disk and provides a local dev server (serve.ts) and a static report builder (build-compare.ts) to view side-by-side A/B comparisons of the generated projects, including detailed rubric scores and blocker analysis.

eval/pbl-v2-planner · high confidence

New Pro mode editing chrome and surface architecture

The EditShell component now provides the complete user interface for Pro mode editing, replacing the previous layout. It introduces a CommandBar for undo/redo and surface commands, a draggable FloatingInsertToolbar for adding content, a FloatingToolbar for formatting selected elements, and a CanvasPager for navigating scenes. Under the hood, the shell uses a registry to mount specific surface components (like slides) while keeping the chrome persistent, ensuring a consistent editing experience across different scene types.

components/edit/EditShell · high confidence

New React-based slide renderer with presentation effects and element support

The renderer package has been replaced with a new React implementation that renders PPT elements (images, text, shapes, charts, code, audio, video) using a \SlideCanvas\ component and a \SlideRendererProvider\ context. This update introduces built-in presentation effects including spotlight, laser pointer, highlight, and zoom overlays, and adds support for animated code blocks with syntax highlighting via Shiki. Charts are now rendered using a lazily-loaded ECharts runtime, and math formulas are supported via embedded KaTeX fonts to ensure correct rendering in snapshots. The new renderer also handles self-hosted Chinese fonts for PPTX imports and provides customizable render slots for images, videos, text, shapes, and tables.

packages/@openmaic/renderer/src · high confidence

New agent management and generation run client libraries

This release introduces server-side endpoints for managing custom agents (create, update, delete, and legacy import) under \/api/agents\ and provides a comprehensive client library (\lib/generation-run-client\) for the browser to interact with generation runs. The client library handles run lifecycle management (starting, fetching, discarding), real-time state tracking via Server-Sent Events, outline review workflows, and synchronization of generated scenes with the classroom interface.

app/api/agents, lib/server/agents · high confidence

New asset storage architecture with browser and server backends

The storage package introduces a new asset management system featuring a browser-side \BrowserAssetStore\ backed by IndexedDB and a server-side \PgAssetStore\ backed by PostgreSQL. The browser implementation uses an allocated-ID registry with an embedded content-addressed byte table, ensuring stable identities and inline reclamation within a single transaction. The server implementation separates the registry (ids, metadata, reference counts) from the byte storage via a pluggable \AssetByteStore\ interface, allowing bytes to reside in a separate object store or column for offline reclamation. This architecture supports indirect byte egress via signed URLs, automatic garbage collection of unreferenced assets, and reference tracking between documents and assets.

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

New classroom ZIP export format with offline HTML and narration scripts

The export system now produces a new \.maic.zip\ format (v1) that includes a structured manifest for agents, scenes, and media, replacing previous ad-hoc structures. Interactive HTML content is now fully self-contained by inlining external assets (CSS, images, scripts) as data URIs, enabling offline playback. Additionally, users can now download the classroom's narration text as a standalone Markdown or DOCX file.

lib/export · high confidence

New client-side library for generation run management

This change introduces a new \lib/generation-run-client\ library that centralizes the client-side logic for AI generation runs. It provides the API layer for starting, tracking, and managing runs (including outline confirmation and retries), implements a real-time follower using Server-Sent Events to keep the UI in sync with run progress, and handles the mapping of run states to user-facing course cards and preview steps. It also manages the synchronization of generated scenes and media assets into the classroom view. Also in this area: 1 commit (1 fix) fixing lib/generation-run-client, lib/utils, lib/workbench.

lib/generation-run-client · low confidence · unverified

New constants for agent visuals and generation limits

The platform now defines shared defaults for generated agent profiles, including a specific color palette and a set of avatar images (teacher, assist, curious, thinker, note-taker) that are cycled for new agents. Additionally, generation limits have been explicitly configured: vision image processing is capped at 20 images, with individual images restricted to a base64 payload of 1 MB and a maximum dimension of 2048 pixels. The system also enforces a 50 MB size limit on course material documents to prevent oversized assets from being processed.

lib/constants · high confidence

New document and media extraction provider architecture

The document extraction system has been restructured into a provider-based registry that supports both document parsing and media (audio/video) extraction. For documents, the system now routes files through a configurable set of providers—including plain text, unpdf, MinerU (self-hosted and cloud), and AliDocMind—selected based on MIME type and required capabilities (text, images, tables, formulas, layout, OCR). For media, a new extraction pipeline supports local processing via ffmpeg (extracting audio transcripts and keyframes) and cloud processing via AliDocMind (extracting transcripts, keyframes, synopses, and OCR). A browser-safe manifest decouples provider metadata from server-only implementation dependencies, ensuring consistent client-side resolution. Image extraction includes automatic downsampling and compression to a 2MB cap, with a limit of 100 derived images per document.

lib/document/extractors · high confidence

New health check endpoint exposes server capabilities and concurrency settings

A new /api/health endpoint has been added to provide real-time visibility into the server's operational state. Clients can now query the application version, check if access-code protection is enabled, retrieve the current server-side generation capabilities, and view the configured parallel scene concurrency limit. This allows monitoring systems and clients to adapt their behavior based on the server's actual configuration and capacity.

app/api/health · high confidence

New in-memory stores for draft refs, iframe keep-alive, and video export

The application introduces several new Zustand-based stores in lib/store to manage specific UI and runtime states. A new draft-generation module and associated course/element refs stores manage ephemeral, non-persisted references for the next message, ensuring that user selections are correctly cleared after sending and isolated per conversation session. An interactive iframe pool store keeps interactive scene iframes alive across scene switches and mode changes to preserve in-iframe state, using an LRU cap to limit memory usage. A video render store manages the lifecycle of the one-click MP4 export, tracking progress, options, and errors independently of the export menu component. Additionally, a KV persistence layer routes Zustand's persist middleware through a new KVStore contract with a state machine for handling backend failures and health reporting, while other new stores handle whiteboard history, canvas viewport syncing, and widget iframe messaging.

lib/store · high confidence

New isolated render service for classroom video exports

Introduces a new, opt-in render-service that handles asynchronous MP4 video exports and synchronous scene previews, decoupling these heavy Node 22 + Chromium + FFmpeg workloads from the main Next.js application. The service provides a bounded HTTP API (POST /owner-bound/render, GET /owner-bound/render/:jobId, POST /preview) with strict resource profiles (standard/low-memory), admission controls (429s with machine-readable reasons), and owner-bound job isolation. It includes robust security measures such as iptables egress lockdown to prevent untrusted HTML from reaching the network, ZIP-bomb guards, and privilege dropping to a non-root user. The service is containerized via a dedicated Dockerfile and entrypoint, and supports local disk or S3 artifact storage.

render-service · high confidence

New material management API endpoints for the workbench

The workbench now exposes a dedicated set of API routes for managing user-uploaded materials. Users can upload files via POST /api/materials, which handles validation, size limits, and triggers background extraction. The new GET /api/materials endpoint lists either the user's personal library or materials bound to a specific agent session, while GET /api/materials/\[id\] retrieves details for a specific upload. Additionally, POST /api/materials/\[id\]/extraction allows users to retry failed extractions or start new ones, and DELETE /api/materials/\[id\] removes uploads to free up quota. These endpoints are gated by server persistence configuration and enforce owner-scoped access control.

app/api/materials · high confidence

New media generation adapters for ComfyUI, Grok, HappyHorse, Lemonade, MiniMax, OpenAI, and OpenRouter

Added new adapter implementations in lib/media/adapters to support image and video generation from ComfyUI, Grok (xAI), HappyHorse (Alibaba Cloud), Lemonade, MiniMax, OpenAI, and OpenRouter. These adapters handle provider-specific API calls, authentication, and result formatting, with built-in security measures such as redirect blocking and workflow file validation for ComfyUI.

lib/media/adapters · high confidence

New outline-language evaluation harness with LLM-as-judge scoring

The eval/outline-language directory now provides a complete evaluation harness for testing how well the system infers language directives from user requirements. The runner (runner.ts) executes real outline generation via generateSceneOutlinesFromRequirements for each test case, then uses an LLM-as-judge (judge.ts) to score the inferred languageDirective against ground truth using a lenient rubric. Results are reported as markdown reports (reporter.ts) with pass/fail details and summary tables. The harness supports diverse language scenarios including pure Chinese/English, technical terminology handling, cross-language learning, immersive instruction, and explicit language overrides, with test cases defined in scenarios/language-test-cases.json. Configuration requires EVAL\_INFERENCE\_MODEL and EVAL\_JUDGE\_MODEL environment variables.

eval/outline-language · high confidence

New quiz editing surface with structured form and undo/redo

Authors can now edit quiz scenes using a dedicated structured form 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 an inline accordion UI. It includes a draggable insert toolbar for reordering, an 'Add question' popover menu, and full undo/redo history for both discrete structural edits and coalesced text typing. The editor also provides real-time validation hints to guide authors before the quiz is playable.

components/edit/surfaces/quiz · high confidence

New runtime status probe endpoint for the agent workbench

A new API endpoint at /api/agent/runtime has been added to expose the current state of the agent workbench. This allows clients to determine if the runtime is usable (checking for both configuration and a valid database connection), whether it is explicitly enabled by intent, and if server persistence is available. This information is used by the workbench client to gate its entry and by other routes (like course library and folders) to decide whether to serve content based on persistence availability.

app/api/agent/runtime · high confidence

New self-contained video export pipeline with local CLI and service-backed MP4 rendering

The video-export-app now provides a unified, self-contained export workflow. Users can download a ZIP file containing the full Hyperframes project, collected assets, and vendored GSAP runtime for local CLI rendering, or upload that same ZIP to a service-backed render endpoint to generate an MP4 directly in the app. The pipeline includes deterministic Quiz question-list scrolling and cover cards, support for multiple locales (including German, French, Vietnamese, and others), and a dedicated path to download sidecar SRT/VTT subtitles without rendering video. Asset collection is robust, falling back to CDN URLs when local blobs are missing, and the system ensures only one export operation runs at a time to prevent state conflicts.

lib/video-export-app · high confidence

New server-driven model settings client and capability system

The workspace now uses a new client-side model settings system (\lib/model-settings\) that reads configuration from the server (\/api/model-config\) to determine available capabilities. This introduces a revision-based view system to handle concurrent updates and conflicts, and exposes a \ModelCapabilities\ interface that maps slots (LLM, TTS, ASR, image, video, webSearch, webFetch, document) to their effective providers. The system includes helpers to determine if specific features like course generation or classroom chat are usable based on the resolved server view, and provides UI layout definitions for the model map.

lib/model-settings · high confidence

New server-side SSE endpoint for owner session events

A new API route at app/api/agent/owner-events/route.ts has been added to provide a durable, sparse Server-Sent Events (SSE) stream for the current owner's session summaries. This endpoint handles owner authentication via cookies, manages event replay limits and resynchronization logic for disconnected clients, and ensures data is scoped to the authenticated owner's identity. It serves as the backend mechanism for clients to receive real-time updates on owner session activities.

app/api/agent/owner-events · high confidence

New server-side model configuration and provider presets

The application now supports server-side model configuration via capability slots and provider presets, allowing operators to define and manage AI model assignments for different features (such as chat, image, video, and TTS) through a centralized system. This change introduces a new configuration module in lib/config that defines capability slots (e.g., 'chat', 'tts', 'image') and maps them to specific model providers, including support for multi-modal token plans like TokenDance and MiniMax. It also adds feature flags to control the availability of new capabilities like the Pi classroom runtime, MAIC Editor, and video export, as well as attribution headers for TokenDance gateway requests to enable partner program tracking.

lib/config · high confidence

New slide editing surface with selection-anchored toolbars and background controls

The slide editing surface now features a new set of UI components for managing slide content. Users can now change the slide background to either a solid color or an image using the new BackgroundControl. When an element is selected, a floating toolbar (AnchoredBar) appears, providing context-specific actions: text elements get formatting controls, while images and other elements get z-order (to-front/to-back) and delete buttons. Image elements additionally offer replace, flip horizontal, and flip vertical actions. The surface also introduces an element picker (ElementPickLayer) for binding elements to scene actions or referencing them in the composer, and supports inserting tables and line presets via dedicated pickers.

components/edit/surfaces/slide · high confidence

New slide navigation rail with drag-to-reorder and insertion zones

The editor now features a new SlideNavRail component that provides a vertical thumbnail strip for managing scenes. Users can drag to reorder slides, resize the rail width, and insert new slides or quizzes between existing ones using hover-revealed insertion zones. The rail also supports inline title renaming and displays indicators for scenes with incomplete content.

components/edit/SlideNavRail · high confidence

New slide thumbnail rendering with media resolution and retry support

The slide-renderer component now includes a new \SlideThumbnail\ component that handles read-only thumbnail display for slides containing images and videos. This component integrates with the new media resolution system (\use-resolved-slide\) to display pending, failed, or disabled media states with appropriate visual indicators (e.g., loading spinners, error messages). It also adds a retry button for failed media resolutions, allowing users to re-attempt media loading directly from the thumbnail view. Additionally, video thumbnails now use a muted, play-badged treatment instead of standard video controls, and images with posters are rendered as static images rather than video elements.

components/slide-renderer · high confidence

New standalone HTML classroom player with offline playback

The standalone-player library now provides a self-contained React application that allows users to export and play classrooms as a single offline HTML file. This player supports full playback of narration, video, and visual effects, and handles various scene types including slides, interactive content, quizzes, and PBL. It features a robust media library that embeds assets as base64 or links to local files, automatically detecting missing media in offline scenarios. The player includes a start overlay to satisfy browser autoplay policies, a caption bar for speech, and discussion cards for AI topics. It also implements specific fixes for WebKit rendering issues with ECharts animations and ensures a graceful fallback for users without JavaScript.

lib/standalone-player · high confidence

New storage primitives and hardened data persistence

The @openmaic/storage package introduces a pluggable persistence layer with browser and HTTP backends for key-value stores, assets, documents, and runtime sessions, alongside a new PostgreSQL backend for user-authored skills. To ensure data integrity and security, the package now enforces strict validation on HTTP base URLs (rejecting unsafe schemes, embedded credentials, and control characters) and sanitizes all PostgreSQL JSONB and TEXT inputs by replacing NUL bytes and lone surrogates, preventing database write failures and injection risks.

packages/@openmaic/storage/src · high confidence

New whiteboard layout evaluation page

A new evaluation page has been added at app/eval/whiteboard that renders a fixed-size canvas (1000x563) using the existing ScreenElement component. It bootstraps a synthetic stage and scene in the global store and exposes a window.\_\_setElements API, allowing external test runners (such as Playwright) to inject PPTElement arrays and verify layout rendering against a standard theme.

app/eval · high confidence

New whiteboard layout quality evaluation harness

A new automated evaluation harness has been added to \eval/whiteboard-layout\ to assess the quality of AI-generated whiteboard layouts. The runner executes multi-turn agent scenarios (defined in JSON files under \scenarios/\) against a target application, capturing screenshots via Playwright at each checkpoint. These screenshots are then scored by a Vision Language Model (VLM) using a rubric that evaluates readability, overlap, rendering correctness, content completeness, and layout logic. The harness generates detailed JSON and Markdown reports summarizing the scores and turn latency, enabling developers to track and improve whiteboard layout quality over time.

eval/whiteboard-layout · high confidence

PBL v2 runtime operations and evaluation engine

The PBL v2 runtime operations module has been significantly expanded to support the new v2 project lifecycle. This includes a new checkpoint transport system for advancing microtasks and milestones, a deterministic completion stats engine that distinguishes between standard knowledge projects and scenario role-plays, and a dynamic proficiency signal pipeline that updates learner assessments based on observations, submissions, and task speed. Additionally, the module introduces a robust evaluator prompt builder and JSON-tail parser to handle LLM-generated feedback, along with helpers for file validation, quiz snapshot integration, and operation argument schemas.

lib/pbl/v2/operations · high confidence

Redesigned narration timeline with inline action editing and cue previews

The ActionsBar component has been completely rewritten to serve as a horizontal, film-strip-style timeline for the scene's narration script. Users can now edit speech lines inline, drag to reorder actions, and insert new cues (speech, spotlight, laser, discussion) via a dedicated ActionPicker popover. The timeline provides immediate visual feedback by replaying spotlight or laser effects on the canvas when hovering over cue cards, and enforces structural rules such as keeping discussion actions terminal and unique.

components/edit/ActionsBar · high confidence

Server-backed storage runtime with HTTP handlers and Postgres persistence

The storage package now includes a server-backed runtime that exposes HTTP contracts for managing assets, documents, and learner runtime data, all persisted to a PostgreSQL backend. This change introduces pluggable HTTP handlers for asset registry operations (including an opt-in indirect byte egress via signed URLs), document storage with DSL validation and migration, and runtime session management for quiz and playback data. A reference server implementation is provided to demonstrate the integration, though it uses a simple bearer-token authentication model that must be replaced with a production identity system before deployment.

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

Server-side agent runtime and access control infrastructure

The server now includes a dedicated agent runtime layer that manages session lifecycle events (such as start, resume, interruption, and media readiness) and exposes specific tools for the agent, including an 'ask\_user' tool for interactive decision points and a suite of course-edit tools for modifying slide content. To support this, the system introduces server-backed persistence for access control, featuring HMAC-signed access tokens with a 7-day validity window and Edge-compatible verification logic, alongside startup warnings for missing or weak access codes. Additionally, the runtime automatically generates concise conversation titles using a background task and enforces strict validation on stage document writes to prevent concurrent clobbering. Also in this area: 4 commits (3 fixes) fixing lib/server; Support for provider-local voice lists and defaults in TTS configuration; Retired Veo 3.1 provider handling and gender-aware voice binding.

lib/server/agent-runtime, lib/server/agent-runtime/course-edit · medium confidence · unverified

Server-side agent runtime and access control infrastructure

The server now includes a dedicated agent runtime layer that manages session lifecycle events (such as start, resume, interruption, and media readiness) and exposes specific tools for the agent, including an 'ask\_user' tool for interactive decision points and a suite of course-edit tools for modifying slide content. To support this, the system introduces server-backed persistence for access control, featuring HMAC-signed access tokens with a 7-day validity window and Edge-compatible verification logic, alongside startup warnings for missing or weak access codes. Additionally, the runtime automatically generates concise conversation titles using a background task and enforces strict validation on stage document writes to prevent concurrent clobbering. Also in this area: 4 commits (3 fixes) fixing lib/server; Support for provider-local voice lists and defaults in TTS configuration; Retired Veo 3.1 provider handling and gender-aware voice binding; Media downloads are now size-limited to prevent excessive memory usage.

lib/server · medium confidence · unverified

Server-side course library and folder management

The workbench now supports a server-backed course library and folder system when a database is configured. Users can create, list, rename, and delete courses (stages) and folders via new API routes, with ownership enforced through the identity seam. Courses can be organized into folders, and membership can be updated to file or unfile courses. The system includes a real-time freshness signal via Server-Sent Events (SSE) to keep the UI in sync with document changes, and supports publishing and unpublishing courses to make them public. All operations are gated by server persistence configuration, ensuring the agent runtime is not required for these features.

app/api/stages · high confidence

Server-side generation run lifecycle and event streaming

The API now supports a complete server-side generation run workflow. Users can start runs with configurable outline review modes (auto, countdown, or wait), hold outlines for manual review, and confirm or retry them. The system enforces active run limits and provides real-time progress updates via Server-Sent Events (SSE) for both individual run events and owner-wide run status changes. Runs can be discarded if they have not yet produced a course, and the API exposes detailed snapshots including media states and material analysis results.

app/api/generation-runs · high confidence

Server-side workspace model configuration and import

Users can now manage model settings (providers and capability slots) directly on the server via the \/api/model-config\ endpoint, which supports reading the current configuration and applying changes like slot assignments or provider updates with optimistic locking. Additionally, a new \/api/model-config/import\ endpoint allows merging previously browser-stored provider settings into the workspace, ensuring existing server-side settings take precedence and providing a detailed report of what was imported or skipped.

app/api/model-config · high confidence

Service-backed MP4 export with one-click download

The app now supports exporting videos as MP4 files via a dedicated render service. Users can submit export archives for rendering, poll for job status, cancel jobs, and download the resulting MP4 directly from the application. The system checks service availability to ensure the MP4 option is only shown when the backend is configured and healthy, falling back to a standard ZIP download if the service is unavailable. This change introduces new API routes for capability checks, job submission, status polling, cancellation, and file streaming.

app/api/export-video · high confidence

Shared choreography spec for consistent video export

The \lib/choreography\ module now provides a single source of truth for playback semantics, ensuring the classroom-video exporter matches the app runtime. This includes a shared timing spec (constants for effects, whiteboard actions, and speech estimation), a deterministic playback cursor for walking scenes and actions, a timeline resolver that maps actions to wall-clock durations, and versioned animation descriptors (e.g., \spotlight.v1\, \laser.v1\) that declaratively define effect animations for both React and non-React renderers.

lib/choreography · high confidence

Site-level access code authentication with rate limiting

The application now supports site-level authentication via an environment variable ACCESS\_CODE. When enabled, the /api/access-code/verify endpoint validates submitted codes using constant-time comparison and issues an httpOnly access token cookie upon success. To prevent brute-force attacks, verification attempts are rate-limited per client identity, with stricter enforcement applied when requests originate from a trusted proxy. The /api/access-code/status endpoint allows clients to check if the access code feature is enabled and whether the current session is authenticated.

app/api/access-code · high confidence

Slide element referencing and classroom completion page

Users can now reference specific slide elements (such as text, images, or charts) directly from the classroom chat, with a new overlay allowing them to pick an element on the slide. Additionally, a completion page is displayed upon finishing a course, and the canvas area now supports a presentation mode with fullscreen toggling and soft-close countdowns for discussions.

components/canvas · high confidence

Unified document and media extraction with transform pipelines

The document processing layer has been restructured to support a unified extraction pipeline for both documents and media assets. Users can now upload a wider range of formats, including audio and video (MP3, MP4, WAV, etc.), which are processed by the AliDocMind provider to generate timestamped transcripts and keyframes. The system introduces a configurable transform pipeline that automatically normalizes text and removes repeated noise (such as headers, footers, and page numbers) from extracted content. Additionally, a new document bundling mechanism allows multiple files to be combined into a single context with intelligent text budgeting and image selection, ensuring efficient usage of model context windows.

lib/document · high confidence

Web search now supports multiple providers including Brave, Baidu, Claude, and Exa

The web search capability has expanded from a single Tavily integration to a multi-provider system. Users can now select from nine search backends: Tavily, Exa, Bocha, Brave (with a keyless scrape fallback), Baidu (aggregating Qianfan, Baike, and Scholar), Claude (using native model tools), MiniMax, Doubao, and SearXNG. The system includes a provider registry with configuration validation, a centralized dispatcher, and a shared utility to truncate queries to 400 characters to prevent API errors.

lib/web-search · high confidence

Whiteboard history, view reset, and element picking

The whiteboard now supports a history feature that automatically saves snapshots before clearing and allows users to restore previous states via a new dropdown panel. A new 'Reset View' button appears when the canvas has been panned or zoomed, allowing users to quickly return to the default view. Additionally, the whiteboard now integrates with the classroom chat to allow users to pick and reference specific whiteboard elements directly from the chat interface.

components/whiteboard · high confidence

Removals

Removal of legacy generation API routes and Canvas toolbar

This change removes the previous generation API endpoints (\/api/generate\, \/api/generate/scene-outlines\, and \/api/generate/scene\) and the \CanvasTool\ component from the slide editor. Users will no longer have access to these specific server-side generation pipelines or the toolbar containing undo, redo, search, and element insertion tools (text, shapes, images, lines, charts, tables, formulas) in the canvas editor.

(repo-wide) · high confidence

Removal of legacy generation pipeline module

The monolithic \lib/generation/generation-pipeline.ts\ file has been deleted from the codebase. This change removes the standalone two-stage generation system (which handled scene outlines and full scene generation) and its associated helper functions, such as cross-page context building and multimodal image formatting. Users relying on this specific legacy pipeline implementation will no longer have access to these internal generation mechanics, as the code has been removed in favor of the refactored structure.

lib/generation · high confidence

Removal of legacy v1 PBL MCP agent modules

The v1 write path for the Project-Based Learning (PBL) generation system has been retired. This change removes the \lib/pbl/mcp\ directory, deleting the \AgentMCP\, \IssueboardMCP\, \ModeMCP\, \ProjectMCP\, and \agent-templates\ modules that previously managed agent roles, issue workflows, and project configuration. Users relying on these specific internal components for PBL generation will need to use the converged v2 implementation.

lib/pbl/mcp · high confidence

Removal of scene-outlines-stream API route

The \app/api/generate/scene-outlines-stream/route.ts\ file has been deleted, removing the Server-Sent Events (SSE) endpoint that previously streamed outline generation results incrementally to the frontend. This change eliminates the specific streaming logic, including the incremental JSON parser and heartbeat mechanism, for this API location.

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

Removal of the standalone web search API endpoint

The dedicated POST /api/web-search route has been removed from the application. This endpoint previously handled web search requests by directly invoking the Tavily provider, requiring the client to supply an API key or relying on a server-side configuration. Its deletion indicates that web search functionality is no longer exposed as a standalone API resource in this location, likely having been integrated into other parts of the system or replaced by a different mechanism.

app/api/web-search · high confidence

Removed PBL Runtime Chat API endpoint

The PBL Runtime Chat API endpoint at app/api/pbl/chat/route.ts has been deleted. This endpoint previously handled @mention routing for student interactions with agents (such as @question or @judge) during PBL runtime, including model resolution and LLM call logic. Its removal indicates a shift away from this specific v1 write path or chat interaction model.

app/api/pbl/chat · high confidence

Removed ThumbnailSlide component

The ThumbnailSlide component and its associated ThumbnailElement helper have been removed from the slide renderer. This eliminates the code responsible for rendering scaled-down previews of individual slides and their internal elements (images, text, shapes, etc.) for thumbnail views.

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

Security

Hardened proxy-media SSRF protection and added size limits

The proxy-media API now prevents DNS rebinding attacks by pinning network connections to the specific IP address validated at connection time, rather than relying solely on URL validation. It also re-validates the target URL at every redirect hop to block redirect-based SSRF attempts. Additionally, the endpoint now enforces a 25 MiB limit on proxied assets by checking both the Content-Length header and the actual blob size, rejecting oversized responses to prevent resource exhaustion.

app/api/proxy-media · high confidence

Secure iframe sandbox for interactive thumbnails

The ThumbnailInteractive component now renders interactive slide previews in an iframe with a stricter sandbox policy. By removing the 'allow-same-origin' permission from the sandbox attributes, the component 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 isolated frame.

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

Architecture

Stage API refactored into modular namespace-based components

The monolithic Stage API implementation in 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, and stage-api-mode) to improve code organization and maintainability. This refactoring extracts shared utilities and type definitions into dedicated files (stage-api-defaults, stage-api-types) and re-exports them from the main entry point, ensuring the public API surface remains consistent while internal logic is better structured.

lib/api · high confidence

Behavioural changes

1 commit (0 fixes) modifying app/api

A change to existing behaviour in app/api — 1 commit, 1 file: “feat(sandbox): let any admitted owner use sandboxes (\#2191)” (refs \#2191). Also in this area: 2 commits (1 fix) modifying app/api, lib/i18n.

(repo-wide), app/api/pbl/v3 · low confidence · unverified

1 commit (0 fixes) modifying components/home, lib/adaptive

A change to existing behaviour in components/home, lib/adaptive — 1 commit, 6 files: “feat(home): adapt homepage and dialogs for mobile (\#2005)” (refs \#2005).

components/home, lib/adaptive · medium confidence · unverified

1 commit (0 fixes) modifying eval/whiteboard-shapes

A change to existing behaviour in eval/whiteboard-shapes — 1 commit, 4 files: “feat(whiteboard): support rotation and custom SVG paths (\#1965)” (refs \#1965).

eval/whiteboard-shapes · medium confidence · unverified

10 commits (5 fixes) modifying lib/server/materials

A change to existing behaviour in lib/server/materials — 10 commits (5 fixs), 12 files: “release: OpenMAIC 1.0.0 — the agent workbench (\#1228)”; “fix(pdf): inline image URLs returned by MinerU gateways instead of decoding them as base64 (\#2076)”; “feat(config): openmaic.yml, capability slots and server-side model configuration (RFC \#1701) (\#1765)”; and 7 more (refs \#1228, \#2076, \#1701, \#1765, \#1794, …).

lib/server/materials · medium confidence · unverified

13 commits (4 fixes) modifying lib/server/model-config

A change to existing behaviour in lib/server/model-config — 13 commits (4 fixs), 12 files: “feat: merge PBL v3 and the shared sandbox into main for v1.4.0 (\#2151)”; “fix(models): resolve Ark Agent Plan model metadata through catalog aliases (\#2022)”; “feat(web-tools): add DeepSeek search and fetch providers (\#1937)”; and 10 more (refs \#2151, \#2022, \#1937, \#1701, \#1765, …).

lib/server/model-config · medium confidence · unverified

16 commits (8 fixes) modifying components/workbench/workspace

A change to existing behaviour in components/workbench/workspace — 16 commits (8 fixs), 15 files: “release: OpenMAIC 1.0.0 — the agent workbench (\#1228)”; “perf(edit): warm the editor before the first Edit switch and stop waiting for editor fonts (\#2074)”; “fix(workbench): re-read the course after a stale manifest so the request preview still hands off (\#2077)”; and 13 more (refs \#1228, \#2074, \#2077, \#2159, \#1794, …).

components/workbench/workspace · medium confidence · unverified

2 commits (0 fixes) modifying packages/@openmaic/generation/src/pbl

A change to existing behaviour in packages/@openmaic/generation/src/pbl — 2 commits, 10 files: “refactor(generation): consume the package everywhere and delete lib/generation (\#1090)”; “feat(generation): move scene generation and PBL single-call planning into the package (\#1087)” (refs \#1090, \#1087).

packages/@openmaic/generation/src/pbl · medium confidence · unverified

2 commits (1 fix) modifying app/workspace

A change to existing behaviour in app/workspace — 2 commits (1 fix), 1 file: “release: OpenMAIC 1.0.0 — the agent workbench (\#1228)”; “fix(workbench): render /workspace without a page-level Suspense (\#2058)” (refs \#1228, \#2058).

app/workspace · medium confidence · unverified

2 commits (1 fix) modifying lib/server/generation

A change to existing behaviour in lib/server/generation — 2 commits (1 fix), 2 files: “release: OpenMAIC 1.2.0-rc.1 (server-first) (\#1794)”; “fix(generation): parse data URLs without regex and cap vision image size (\#1902)” (refs \#1794, \#1902).

lib/server/generation · medium confidence · unverified

22 commits (1 fix) modifying public

A change to existing behaviour in public — 22 commits (1 fix), 50 files: “chore: update Ollama logo to official version (\#400)”; “Initial commit: OpenMAIC AI classroom platform”; “Add PBL v2 runtime APIs and classroom UI (\#799)”; and 19 more (refs \#400, \#799, \#1114, \#2151, \#1044, …).

public · medium confidence · unverified

3 commits (1 fix) modifying lib/agent-runtime

A change to existing behaviour in lib/agent-runtime — 3 commits (1 fix), 2 files: “release: OpenMAIC 1.0.0 — the agent workbench (\#1228)”; “fix(agent): recover conversations after personal Skill deletion (\#2086)”; “feat(agent): make generate\_video asynchronous with a placeholder ref (\#1267)” (refs \#1228, \#2086, \#1267).

lib/agent-runtime · medium confidence · unverified

6 commits (2 fixes) modifying lib/prosemirror

A change to existing behaviour in lib/prosemirror — 6 commits (2 fixs), 16 files: “Initial commit: OpenMAIC AI classroom platform”; “feat(maic-editor): slide surface — MAIC Editor v0 (epic \#562) (\#615)”; “fix(editor): preserve imported shape label insets in legacy Pro (\#2024)”; and 3 more (refs \#562, \#615, \#2024, \#2159, \#2018).

lib/prosemirror · medium confidence · unverified

6 commits (3 fixes) modifying lib/pbl

A change to existing behaviour in lib/pbl — 6 commits (3 fixs), 12 files: “fix(pbl-v3): label the next milestone after recap (\#2199)”; “feat(edit): course-level undo timeline for manual and agent edits (\#2159)”; “fix(pbl-v3): show the current milestone choice in preview (\#2201)”; and 3 more (refs \#2199, \#2159, \#2201, \#2191, \#2205, …). Also in this area: 2 commits (2 fixes) fixing lib/pbl; 2 commits (1 fix) modifying e2e, lib/pbl, scripts.

lib/pbl/v3 · medium confidence · unverified

7 commits (2 fixes) modifying packages/@openmaic/generation/src/prompts

A change to existing behaviour in packages/@openmaic/generation/src/prompts — 7 commits (2 fixs), 3 files: “refactor(pbl): retire v1 write path and dead UI, converge on v2 (\#1060)”; “feat(generation): scaffold @openmaic/generation with pipeline types and packaged prompt assets (\#1063)”; “refactor(generation): consume the package everywhere and delete lib/generation (\#1090)”; and 4 more (refs \#1060, \#1063, \#1090, \#1586, \#1966, …).

packages/@openmaic/generation/src/prompts · medium confidence · unverified

API exposes parallel scene concurrency configuration

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

Action-level navigation and robust playback resume

The playback engine now supports jumping to specific speech actions within a scene, allowing users to skip forward or backward to key narration points. This navigation is constrained to 'safe' paths that do not cross actions with side effects (such as video playback or widget state changes) to ensure the visual state can be correctly reconstructed. Additionally, the system introduces granular resume capabilities: it persists the exact action index and ID to resume playback precisely where the user left off, and automatically resumes an interrupted lecture after a Q&A or discussion session ends, provided the interruption was user-initiated or timed out. Browser-native TTS playback is also improved with a cancel-and-respeak pattern to handle pausing reliably across browsers.

lib/playback · high confidence

Agent registry refactored to server-side persistence with per-agent TTS voice selection

The agent registry has been restructured to move custom agent storage from local browser storage to the server API (\/api/agents\), ensuring agent configurations persist across sessions and devices. The system now distinguishes between built-in agents (read-only, defined in code), custom user agents (managed via the server), and generated stage agents (in-memory). Additionally, agents now support per-agent TTS voice configuration, allowing users to assign specific voice models and designs to individual agents for consistent audio output.

lib/orchestration/registry · high confidence

Audio library refactoring and new capabilities

The audio library has been significantly restructured and expanded. A new agent voice system (\agent-voice.ts\, \agent-voice-options.ts\) centralizes TTS voice resolution for agents, supporting features like auto-voice quality and timbre stability. Narration handling is improved with \adopt-cached-narration.ts\ to migrate local browser audio to server-backed assets, and \audio-duration.ts\ to persist audio duration for timeline accuracy. Provider management is enhanced with \provider-display.ts\ for localized names and \provider-enablement.ts\ for a unified enablement model. New playback logic in \discussion-audio.ts\ reuses a single media element to fix mobile autoplay issues, while \browser-tts-preview.ts\ adds language detection for previews. Additional utilities include \json-stream.ts\ for parsing concatenated JSON, \pcm-wav.ts\ for container wrapping, and \narration-allocations.ts\ for tracking asset references.

lib/audio · high confidence

Automatic one-way import of legacy browser data to the server

With persistence now server-only, the application silently and automatically migrates courses, custom agents, model settings, and device cache data from the previous browser-based storage (IndexedDB/localStorage) to the server on the first load after an upgrade. This process runs once per browser, ensuring data integrity by binding the browser to the current owner and handling conflicts (such as duplicate course IDs) by creating fresh IDs, while preserving local state like playback positions and media cache records.

lib/legacy-browser-import · high confidence

Bounded whiteboard summarization and conflict detection for agent prompts

The orchestration layer now includes new summarizers that prevent prompt context overflow and improve agent awareness of whiteboard layout issues. A shared code-line budget caps the amount of code content and IDs included in summaries, ensuring that code-heavy boards do not exhaust the prompt window. A new peer-context summarizer explicitly instructs agents to avoid repeating previous speakers' points. Additionally, a geometric conflict detector identifies overlapping elements, line intersections, and canvas clipping, surfacing these layout issues directly in the system prompt so agents can correct them.

lib/orchestration/summarizers · high confidence

Chat system refactored with new quiz integration and structured output handling

The chat module has been restructured to support new classroom features and improve reliability. A new \structured-output.ts\ module (renamed from orchestration) now handles JSON parsing with improved resilience against malformed model outputs, including logic to suppress structured residue from appearing as visible speech. Quiz results are now integrated into the chat context via \buildQuizResultsForStoreState\, allowing the AI to use graded quiz answers for more relevant responses. Additionally, \buildLectureNotes\ generates structured notes from scene actions, and \normalizeCueUserOptions\ ensures suggested replies are clean and deduplicated.

lib/chat · high confidence

Classroom generation is now asynchronous

The /api/generate-classroom endpoint no longer blocks while creating content; it now accepts a request and immediately returns a 202 Accepted status with a job reference. This shift to an asynchronous model allows the system to handle generation runs in the background, improving responsiveness for users initiating classroom creation.

app/api/generate-classroom · high confidence

Classroom page now renders via the new ClassroomSurface component

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

Classroom session management and generation ownership

The classroom module now enforces strict generation ownership and manages session lifecycle. A new permission system (generation-permission.ts, stage-ownership-signal.ts) gates AI generation to the course owner, preventing unauthorized usage of provider budgets by visitors or during network outages. Session initialization (use-classroom-session.ts) now automatically cleans up media allocations, narration, and whiteboard history when a course unmounts, and handles ownership resolution with bounded retries. Additionally, a new complete-summary module (complete-summary.ts) provides logic to calculate and display final quiz scores and scene counts for course completion.

lib/classroom · high confidence

Editor canvas now supports laser pointer and spotlight cues via descriptor-driven animations

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

Editor canvas types migrated to @openmaic/dsl and text editing frame refined

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

Enhanced whiteboard rendering and widget integration in action engine

The action engine now renders whiteboard math content using KaTeX for proper visual formatting instead of displaying raw LaTeX text. It also introduces support for code elements on the whiteboard, including new action types for drawing and editing code lines. Additionally, the engine now supports communication with widget iframes via a configurable message callback, enabling widget state changes and annotations to be executed through the action pipeline.

lib/action · high confidence

Fixes canvas gesture failures in Safari and enables text insertion

The slide editor now works reliably in Desktop Safari, where drag, resize, rotate, and shape-keypoint gestures previously failed due to a missing TouchEvent global; a new isTouchEvent helper uses changedTouches for detection. Text elements can now be created directly on the canvas via click or drag selection, inserting a default-sized, centered, empty text box. Alignment snap lines are now shared across drag and resize operations for consistent positioning, and the canvas scale is locally mirrored to prevent initial mis-scaling when multiple canvases are mounted.

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

Fixes whiteboard aspect ratio rendering and adds chat element referencing

Whiteboards now render with the correct 16:9 landscape aspect ratio by normalizing inverted viewport ratios (where width/height was mistakenly stored instead of height/width) and clamping values to a plausible range. Additionally, a new mechanism allows whiteboard elements to be referenced in classroom chat, enabling users to link to specific parts of a whiteboard from the chat interface.

lib/whiteboard · high confidence

Generation preview now visualizes web search sources and uses a new run-client architecture

The generation preview page has been refactored to use a new \generation-run-client\ for managing run state and commands, replacing the previous session-based approach. This change introduces a new \visualizers.tsx\ component that provides animated, step-specific visual feedback, including a dedicated web search visualizer that displays search results with a scanning beam effect. The preview now supports a persistent outline review intent across page reloads and integrates with the new model capabilities system.

app/generation-preview · high confidence

Image elements now resolve AI-generated placeholders and display unified retry/failure states

The ImageElement components now correctly display AI-generated images in the editor canvas, which previously showed broken-image icons because raw generation placeholders were rendered instead of resolved URLs. A new \useResolvedImageSrc\ hook centralizes resolution logic for both the read-only \BaseImageElement\ and the interactive editor variant, ensuring consistent behavior. Additionally, image elements now display explicit failure notices (e.g., content sensitive) and retry buttons, with the retry action targeting the correct scene context. The import paths for slide types have also been updated to use \@openmaic/dsl\ directly, and CSS filter handling has been refactored to support unit-aware filter values.

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

Image generation now uses server-configured providers with enhanced security and error handling

The image generation API has shifted from client-overridable provider selection to a server-managed configuration model. Provider selection is now driven by the server's image slot configuration, with legacy headers (x-image-provider, x-api-key, x-base-url) deprecated and only functional when the slot is unassigned. Client-supplied base URLs are now validated against SSRF attacks, and managed providers ignore client-sent API keys and base URLs to prevent credential forwarding. Upstream error details are no longer exposed to the client; instead, generic messages are returned while specific refusal reasons (missing API key, missing model) are handled via structured error codes. The implementation also introduces a new step-based generation flow and stricter provider disablement checks.

app/api/generate/image · high confidence

Improved bundler compatibility and minor code fixes in PptxGenJS

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

Improved chart layout and stability in slide renderer

Chart rendering in slides is now more robust and visually consistent. The component now includes defensive checks to prevent crashes when chart data is malformed or empty. Additionally, short Cartesian charts are better fitted to their containers, and axis labels are preserved and readable by enabling the ECharts legacy grid contain-label feature and adjusting grid margins. Type definitions for chart elements have also been updated to import directly from the @openmaic/dsl package.

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

Improved model verification reliability and error privacy

The verify-model API now supports server-side saved provider configurations, allowing users to test models linked to stored credentials without exposing API keys in the request body. It also uses a unified LLM wrapper to probe the exact model specified, ensuring that fallback logic does not mask connection issues with the target model. Additionally, error responses are now classified by HTTP status code rather than parsing raw error messages, which prevents sensitive upstream provider details from leaking to the client while providing clearer, standardized error feedback.

app/api/verify-model · high confidence

Improved quiz grading validation, model resolution, and error logging

The quiz grading API now validates that the 'points' field is a positive finite number, returning a clear error if invalid. Model resolution has been refactored to use a centralized helper that supports per-model thinking configuration and server-managed model selection, replacing the previous manual header parsing. Additionally, error logging has been enhanced to include the question snippet and points in failure messages, aiding in debugging.

app/api/quiz-grade · high confidence

Improved reliability for AI regeneration and outline synchronization

The client-side agent logic now handles AI-generated content more robustly. When regenerating a slide, the system preserves the existing canvas (including theme and viewport) and correctly manages the 'restore previous' snapshot, ensuring that narration actions are not accidentally wiped during regeneration. Additionally, scene outlines are now matched to slides using a stable unique identifier rather than a mutable order index, preventing incorrect outline data from appearing after slides are reordered.

lib/agent/client · high confidence

Improved resilience for malformed slide shapes and refined type imports

The ShapeElement component now validates shape geometry using @openmaic/geometry and gracefully recovers text content when a shape's path or viewBox is malformed, falling back to a text-only representation instead of failing to render. Additionally, type definitions for shapes and gradients are now imported directly from the @openmaic/dsl package, and the component uses safe fallbacks for viewBox dimensions to prevent rendering errors with invalid data.

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

Improved table rendering stability and inline math support in slides

The table renderer now tolerates malformed or non-array slide data by safely defaulting to empty arrays, preventing crashes during playback. It also supports explicit row heights from the slide data and renders inline mathematical formulas within table cells. Additionally, text formatting now preserves HTML tags (such as those used for inline math) while converting newlines and spaces, ensuring consistent display of mixed content in both tables and text elements. Also in this area: 3 commits (3 fixes) fixing components, lib/store.

components/slide-renderer/components/element/TableElement, components/slide-renderer/components/element/TextElement · medium confidence

Improved typography, layout stability, and editor styling in the slide editor

The slide editor now supports non-Latin scripts (Cyrillic, Vietnamese, CJK) by loading Inter and CJK fonts via @fontsource unicode-range subsets instead of next/font, ensuring consistent rendering across languages. Layout shifts caused by scrollbar toggling and Radix modal overlays are eliminated by enforcing a stable vertical scrollbar and neutralizing redundant body spacing. The editor's text formatting is refined: list markers are visible in edit mode without affecting playback, the color picker is compacted, and the format painter cursor is restored. Additionally, the root layout initializes the dark theme before paint to prevent flash, and integrates new workbench and storage health components.

app · high confidence

Inline math is stored as LaTeX source and rendered client-side

The sanitization logic in lib/sanitize now converts inline mathematical formulas from their rendered HTML representation (KaTeX trees) into plain LaTeX source text wrapped in a specific marker attribute. This change ensures that only the raw LaTeX is persisted in the database, while client applications are responsible for typesetting the formulas using KaTeX when displaying slides. This approach reduces server-side rendering complexity and ensures that non-rendering consumers (like plain-text views or exports) can still display the formula source.

lib/sanitize · high confidence

Interactive scenes no longer reload on remount and PBL v1 UI is retired

Interactive scenes now persist their iframe state across mode switches and remounts, preventing unnecessary reloads and preserving the user's position in the interactive content. The legacy PBL (Project-Based Learning) v1 UI components, including the chat panel, issue board, and role selection, have been removed in favor of the new PBL v2 runtime and UI. Additionally, a new error banner is displayed for interactive scenes that encounter runtime errors, and the classroom completion page now includes animated confetti and sparkles to celebrate course completion. Also in this area: 3 commits (2 fixes) fixing components.

components/scene-renderers, components/scene-renderers/pbl · medium confidence

Introduces hardened agent runtime with tool allowlisting and execution timeouts

The agent runtime now enforces stricter safety and reliability controls. A new tool allowlist mechanism blocks any tool not explicitly enabled in the build, preventing unauthorized tool execution. Additionally, every tool call is now bounded by a configurable execution timeout (defaulting to 10 minutes, with specific overrides for long-running tools like scene generation) to prevent sessions from hanging indefinitely on unresponsive providers. The runtime also includes improved handling of provider-specific metadata to ensure multi-turn tool conversations do not error, and a stub quota hook to prepare for future credit/budget enforcement.

lib/agent/runtime · high confidence

Introduces server-backed persistence for chat sessions and course thumbnails

The application now uses a server-backed persistence model for chat sessions and course thumbnails, replacing the previous browser-only storage approach. Chat sessions are migrated to a new \RuntimeStore\ with dedicated storage utilities (\chat-storage-core.ts\, \chat-storage-lock.ts\) that handle legacy data conversion, concurrency locking, and synchronization. Course thumbnails are now cached in a server-backed store (\course-thumbnail-cache.ts\) with versioning and eviction policies, and loaded via a bounded loader (\course-thumbnail-loader.ts\) to optimize performance. This change ensures data consistency and availability across devices, while maintaining a smooth user experience through efficient caching and loading strategies.

lib/utils · high confidence

Introduces server-backed whiteboard runtime with legacy import and code-edit fixes

The whiteboard runtime now relies on a new server-backed persistence layer, replacing the previous browser-local model. This change introduces a one-way import mechanism for legacy browser whiteboards to ensure data continuity, while automatically correcting inverted viewport ratios (e.g., 16:9 landscape) during legacy snapshot imports. Additionally, the runtime enforces stricter validation for code-line edits, anchoring replacements in document order to prevent sequence conflicts and ensuring that code elements are properly normalized before being persisted.

lib/whiteboard/runtime · high confidence

Migrate document persistence to server-backed storage with legacy import

The app's document persistence has shifted from local browser storage to a server-backed backend. Existing documents created in the browser are automatically migrated to the new server store on first open, preserving user content while retiring the legacy write path. The current editor position is now tracked separately from the document metadata to ensure playback state is not persisted as part of the canonical document.

lib/document-store · high confidence

Migrate internationalization to i18next with expanded language support

The application's localization system has been refactored from a static, TypeScript-based object structure to the i18next framework. This change enables dynamic loading of translation resources and expands supported languages from two (Chinese, English) to twelve, including Japanese, Russian, Arabic, Portuguese, Korean, Spanish, French, Vietnamese, and German. The migration introduces a new configuration layer (\config.ts\) and a locale registry (\locales.ts\), while removing the previous hardcoded translation files (\chat.ts\, \common.ts\, \generation.ts\, etc.). Product copy for the workbench chat surface is now managed via a dedicated TypeScript module (\workbench.ts\) to support hook-free presentation helpers, ensuring consistent translation resolution across the interface.

lib/i18n · high confidence

New CI and release gates for package integrity, dependency contracts, and video-export assets

The repository now includes a suite of new scripts that enforce stricter quality and release gates. \check-package-version-bumps.mjs\ and \check-internal-dependency-ranges.mjs\ ensure that publishable package inputs trigger version bumps and that internal \@openmaic\ dependencies use the correct \workspace:^\ range to prevent duplicate installations. \assert-pg-contract-suites.mjs\ verifies that PostgreSQL contract tests actually execute against a real database by checking insert counters, while \check-i18n-keys.mjs\ enforces alignment across locale files. Additionally, \check-node-engine-contract.mjs\ validates that the root Node engine minimum satisfies all direct production dependencies, and \assert-vendor-maic-importer.mjs\ ensures the runtime PPTX parser bundle is present. Finally, new scripts (\generate-video-export-katex.mjs\, \generate-video-export-noto-cjk.mjs\, \generate-video-export-noto-script-fonts.mjs\) generate deterministic font assets for Quiz video exports, and \generation-node-smoke.mjs\ provides a smoke test for the generation package.

scripts · high confidence

New hooks for agent runtime, ASR availability, and course thumbnails; refactored audio and theme logic

This change introduces several new React hooks in lib/hooks: useAgentRuntimeAvailable probes the server to gate agent features, useASRAvailable unifies speech input gating based on server model settings and browser support, and useCourseThumbnails manages lazy loading of course thumbnails with concurrency controls. The existing useAudioRecorder is refactored to delegate ASR configuration to the server's model capabilities and supports continuous recognition, while useTheme is moved to lib/hooks and updated to prevent theme flash by deferring document class application until the stored theme is loaded. Additionally, useCanvasOperations is updated to import types from @openmaic/dsl, and legacy hooks like useDraftCache and useSceneGenerator are removed.

lib/hooks · high confidence

OpenMAIC 1.2.0-rc.1: Server-first architecture with PostgreSQL and centralized model configuration

The platform shifts from a browser-driven, serverless-compatible model to a server-first architecture requiring a long-running Node.js process and a PostgreSQL database. Course generation, media assets, and user identity are now managed server-side, enabling persistent runs that survive page closures and restarts. Model configuration is centralized via \openmaic.yml\, replacing the legacy environment variable and browser-based settings, with provider keys encrypted and stored on the server. This release introduces a one-way import to migrate existing browser-stored courses to the server, deprecates serverless deployment targets like Vercel, and enforces strict owner-based persistence and asset quotas.

(repo-wide) · high confidence

PBL v2 core schema, legacy migration, and streaming chat infrastructure

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

PBL v2 runtime state is persisted to the server-backed RuntimeStore

Learner progress in PBL v2 projects is now tracked in the server-backed RuntimeStore instead of the document. The runtime drains client-side event outboxes into the store, folds those events to reconstruct learner state, and writes periodic snapshots. When saving documents, learner state is stripped from the project payload to prevent duplication, while the original v1 record (including chat history) remains untouched. This ensures state survives across sessions and devices via the server store.

lib/pbl/v2/runtime · high confidence

PDF parsing now uses server-managed document slots with stricter client URL validation

The PDF parsing endpoint has been refactored to route through the new document extraction system, allowing the server to assign a provider via workspace configuration slots rather than relying solely on client-supplied provider IDs. For providers configured by the server (admin-managed), client-sent API keys and base URLs are now ignored to prevent credential leakage and SSRF attacks. Additionally, any client-supplied base URLs for unmanaged providers are validated before use, and error logs now include the resolved provider ID and filename for better debugging.

app/api/parse-pdf · high confidence

Prompt system refactored with conditional media snippets and simplified loading

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

Quiz grading, math rendering, and state persistence refactored

The quiz module now uses a dedicated grading engine that resolves persisted answer keys to option values before grading choice questions, ensuring correct scoring even when keys were stored as labels. Quiz text now renders LaTeX formulas using KaTeX for proper mathematical display. Additionally, quiz state persistence has been migrated to the RuntimeStore, with a one-time compatibility layer that imports legacy browser-local storage data before retiring the old keys.

lib/quiz · high confidence

Redesigned course generation interface with streaming outlines and status tracking

The course generation workflow has been overhauled to support a more interactive and transparent experience. A new \CourseRunStatusLabel\ component now displays real-time run states (such as outlining, generating, or paused) with appropriate icons and localized text on course cards. The \OutlinesEditor\ has been significantly expanded to support streaming updates, allowing users to see outlines appear in real-time with auto-scrolling, and includes a validation gate that prevents confirmation until all scenes have titles. Scene types (slide, quiz, interactive, PBL) now have distinct visual themes, and the editor supports drag-and-drop reordering. The \GenerationToolbar\ has been updated to manage course materials (with format validation and upload limits) and model settings, while the legacy \GeneratingProgress\ component has been removed in favor of these new, more granular UI elements.

components/generation · high confidence

Refactor agent profile generation to support per-agent voice assignment and model resolution

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

Refactored classroom loading logic and added generation placeholder UI

The classroom loading pipeline has been extracted into a reusable \ClassroomSurface\ component to ensure consistent behavior between the standalone page and the workspace pane, while the pane now correctly displays a \CourseGeneratingPlaceholder\ with progress status and retry links when a course is being generated or paused. Also in this area: 3 commits (3 fixes) fixing components, lib/store.

components/classroom · medium confidence · unverified

Refactored scene generation API to use centralized model resolution and normalized PBL content

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

Roundtable component refactored with presentation mode and audio indicators

The Roundtable component has been significantly refactored to support a dedicated presentation mode and improved audio feedback. A new \PresentationSpeechOverlay\ handles speech bubbles with collapsed/expanded states, while a new \AudioIndicator\ component provides visual feedback for audio generation and playback states. The main component now accepts a broader set of props for presentation controls, discussion pausing/resuming, and soft-closing grace periods, and has moved shared constants and avatar logic into dedicated files for better organization.

components/roundtable · high confidence

Scene content generation now supports per-stage model routing and vision image pre-resolution

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

Server-backed asset persistence and unified media handling

The media subsystem now routes all generated and imported media through a server-backed asset pool instead of relying solely on local browser storage. This change introduces a new asset manifest system that enumerates document references to ensure exports contain only valid, referenced assets, and implements a cross-tab replacement channel to keep media leases synchronized across open browser windows. Additionally, the media fetch layer now routes cross-origin requests through a same-origin proxy to enforce SSRF guards and handle CORS, while a unified commit primitive ensures that bytes are retained locally when the server store is full, preventing unnecessary re-generation costs.

lib/media · high confidence

Server-backed persistence with asset lifecycle and legacy browser import

The application now requires server-backed persistence, removing the previous browser-storage fallback. All durable reads and writes for courses, learner runtime, and assets are routed through the embedded \/api/persistence\ endpoint. To support this transition, a one-way import mechanism has been added to migrate data from previous browser-local storage to the server. The asset system now features a configurable byte store (S3 or PostgreSQL), a periodic reclamation collector to manage storage quotas and prevent leaks, and an opt-in indirect egress mode for signed URL access. Additionally, the server now manages the full lifecycle of assets, including automatic release upon course deletion. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Introduce Material Library for organizing and attaching source files.

lib/persistence · low confidence · unverified

Server-backed runtime persistence with configurable backend and learner identity

The runtime layer now exclusively uses a server-backed \RuntimeStore\ instead of local browser storage. This change introduces a new bootstrap configuration (\configureRuntimeStorage\) that allows the application to specify the persistence backend (e.g., an HTTP client) and the learner identity key. A singleton store is managed via \getRuntimeStore()\, and a new \learner-key\ module handles device-anonymous identity resolution with race-safe persistence. Additionally, payload validators for chat, quiz attempts, and whiteboards are now enforced through \APP\_RUNTIME\_PAYLOAD\_VALIDATORS\, and stage deletion operations are wrapped in safe, timed-out cascades to prevent hanging.

lib/runtime · high confidence

Server-configured image providers are now admin-managed and client-overrides are restricted

The /api/verify-image-provider endpoint now distinguishes between server-configured (managed) providers and user-selectable ones. For managed providers, client-supplied API keys and base URLs are ignored, and the server enforces a force-disabled state regardless of client input. Additionally, client-supplied base URLs are now validated against SSRF attacks before use, and error responses no longer leak upstream provider details. The endpoint also supports testing saved provider configurations via a JSON body, ensuring that connectivity checks use the server's resolved credentials and model settings.

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

Server-managed ASR and video providers with hardened SSRF protection

The transcription and video provider verification endpoints now enforce server-side configuration precedence: admin-configured providers are pinned and their credentials/endpoints cannot be overridden by client-supplied keys or base URLs, while client-chosen providers are strictly validated against SSRF (including DNS rebinding and redirect attacks) and rejected if the server has disabled user-provided providers. Error responses are sanitized to prevent leaking upstream details, and the transcription route now supports resolving models via saved provider references.

app/api/transcription · high confidence

Server-side model resolution and structured error logging in chat API

The chat API now resolves the LLM model, API key, and thinking configuration on the server side via a new \resolveModel\ function, replacing the previous client-supplied credential resolution logic. This change centralizes model routing and credential handling, allowing for server-side overrides and per-stage model configuration while still honoring client-specified model routes. Additionally, error logging has been enhanced to include specific context such as the model name and message count, improving troubleshooting visibility for failed requests.

app/api/chat · high confidence

Slide editor configuration files migrate types to @openmaic/dsl and apply Prettier formatting

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

Slide element rendering now uses shared DSL types and improved media/code handling

The slide renderer's element components (Code, Image, Video, Chart, Latex, Line, etc.) have been updated to import their type definitions from the \@openmaic/dsl\ package instead of the local \@/lib/types/slides\ shim, ensuring type consistency across the platform. For images, the \BaseImageElement\ and \ImageElement\ now use a unified \useResolvedImageSrc\ hook to correctly resolve generated media placeholders (\gen\img\\*\) in both read-only and interactive modes, preventing broken-image icons and providing clearer retry/failure states. The code element introduces a new \BaseCodeElement\ with Shiki-based syntax highlighting and a line-by-line typing animation. Chart rendering includes defensive checks to prevent crashes on malformed data and improves axis label handling. Latex elements now support explicit color styling. Also in this area: 4 commits (3 fixes) fixing components.

components/slide-renderer/components/element · medium confidence · unverified

Soft-close sessions and enhanced lecture notes navigation

The chat component now supports a 'soft-close' state for discussion and Q&A sessions, giving users a 15-second grace period to continue the conversation before it automatically ends; this is visible via an amber pulsing indicator and a countdown timer in the session list and chat bubbles. Additionally, the lecture notes view now supports jumping to specific actions (speech, discussion, and interactive widgets like highlight or annotation) within the current scene, and the proactive card in presentation mode can now render inside the fullscreen container to ensure visibility.

components/chat · high confidence

Speech button now respects ASR availability and supports continuous recording

The SpeechButton component in the audio module now disables the microphone button when Automatic Speech Recognition (ASR) is unavailable or not configured, ensuring users cannot initiate recording in unsupported environments. It also introduces a new \continuous\ prop that allows the button to maintain browser-native ASR sessions until manually stopped, and automatically cancels an active recording if the button is disabled while recording is in progress.

components/audio · high confidence

Stream buffer now supports TTS synchronization and action completion waiting

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

UI component library formatting and accessibility refinements

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

Unified TTS provider resolution and structured error handling

The TTS API now delegates provider selection to a central configuration system, rejecting client-supplied provider overrides in favor of the server-configured TTS slot to prevent SSRF and credential leakage. It introduces structured error responses for rate limits (HTTP 429), invalid provider models, and Qwen voice cloning failures, while also supporting a new voice registration endpoint for stable, deterministic voice IDs across sessions. Also in this area: 2 commits (1 fix) modifying app/api, lib/i18n.

app/api/generate/tts, app/api/generate/voice · medium confidence

Unified stage chrome and richer scene thumbnails

The stage UI now consolidates global controls (language, theme, settings, Pro mode toggle, and exports) into a single \HeaderControls\ component that is shared between the playback header and the Pro-mode edit CommandBar, ensuring a stable, pixel-identical control cluster across modes. Scene thumbnails in the sidebar have been upgraded to show live previews for interactive scenes (via an iframe) and consistent stylized mockups for quizzes and PBL, replacing the previous icon-only stubs to provide visual parity between playback and edit modes. Additionally, the scene renderer has been simplified to remove the edit-mode branch (since Pro mode uses a separate EditShell), and the sidebar now supports an \isCourseComplete\ prop and improved viewport-aware rendering for thumbnails.

components/stage · high confidence

Unified thinking controls, reasoning stream handling, and new provider support

The AI library now features a centralized system for configuring and managing model 'thinking' (reasoning) capabilities, allowing users to control reasoning effort, level, and budget across a significantly expanded set of providers. This includes new support for Azure OpenAI, Amazon Bedrock, and Xiaomi MiMo, alongside updated model catalogs for OpenAI (GPT-5.6), Anthropic (Claude Opus 4.8), and others. To ensure reasoning chains are preserved correctly—especially for OpenAI-compatible providers like DeepSeek and Kimi that stream reasoning in separate fields—the system now normalizes these streams into standard formats and handles multi-turn context retention. Additionally, the library introduces model fallbacks for retryable failures and aliases for model ID resolution, while removing legacy i18n and utility modules.

lib/ai · high confidence

Video elements now use a unified resolution system with inline playback and improved error handling

The VideoElement component has been refactored to use a new \useResolvedVideoMedia\ hook that centralizes media resolution, replacing direct store access with a structured \MediaResolution\ state. This change introduces \playsInline\ to video elements, ensuring videos play inline on mobile devices rather than forcing fullscreen. Error handling is now more granular: failed generations display specific failure notices (e.g., content sensitivity) alongside retry buttons, and disabled media states are clearly indicated. The component also imports types from \@openmaic/dsl\ and integrates with model capability settings to respect server-side media generation configurations.

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

Video export now uses a deterministic, multi-pass compiler pipeline with legacy PBL support

The video export engine has been refactored into a strict, deterministic pipeline of isolated passes (normalize, timeline, assets, geometry, visuals, interactive, reflow, emit) that compile scenes into a validated VideoTimeline IR manifest. This change introduces deterministic scene ordering and action validation, precise geometry resolution for effects and video clips, and asset deduplication with diagnostic reporting. It also adds support for self-contained static interactive HTML scenes and deterministic Quiz question-list scrolling. Crucially, it retains the ability to export historical PBL v1 scenes via a permanent read-only adapter, ensuring legacy content remains exportable while the system converges on the v2 data model.

lib/video-export/passes · high confidence

Video generation now uses server-configured providers with stricter security and error handling

The video generation API has shifted from client-overridable provider settings to a server-managed configuration model. Providers are now resolved from the server's video slot configuration, meaning client-supplied headers for provider, API key, and base URL are deprecated and only accepted when no server slot is assigned. For managed providers, client API keys and base URLs are ignored, and client-supplied base URLs are validated against SSRF attacks. Additionally, error responses have been hardened to prevent upstream provider error details from leaking to the client, and the route now supports server-side model pinning and force-disabled provider checks.

app/api/generate/video · high confidence

Whiteboard code support and orchestration simplification

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

Workbench UI logic and composer behavior

This update introduces a suite of new modules in the workbench library that define core user-facing behaviors. It establishes a shared registry for agent skills, handling caching, owner-scoped invalidation, and localized display labels. The composer's input handling is refined with a unified tokenization model, a new \/\ skill handle insertion policy (replacing the previous pill-based picker with inline text), and robust Enter-key send logic that correctly handles IME composition. Navigation and layout controls are standardized: classroom header visibility, back-button behavior, and exit routing are now resolved via pure functions based on the workbench's open/playback state. Additionally, course chat bootstrapping logic prevents the creation of empty sessions on course navigation, and course mention parsing (\@\) is implemented with specific ordering and limit rules. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 1 commit (1 fix) fixing lib/generation-run-client, lib/utils, lib/workbench; 2 commits (2 fixes) fixing lib/workbench; Introduce Material Library for organizing and attaching source files.

lib/workbench · low confidence · unverified

Fixes

11 commits (7 fixes) fixing lib/server/material-extraction

A fix in lib/server/material-extraction — 11 commits (7 fixs), 15 files: “release: OpenMAIC 1.0.0 — the agent workbench (\#1228)”; “fix(pdf): inline image URLs returned by MinerU gateways instead of decoding them as base64 (\#2076)”; “feat(config): openmaic.yml, capability slots and server-side model configuration (RFC \#1701) (\#1765)”; and 8 more (refs \#1228, \#2076, \#1701, \#1765, \#1794, …).

lib/server/material-extraction · medium confidence · unverified

11 commits (8 fixes) fixing lib/server/generation/steps

A fix in lib/server/generation/steps — 11 commits (8 fixs), 10 files: “fix(audio): migrate Qwen voice cloning to CosyVoice (\#1949)”; “fix(generation): explain exhausted plan quotas (\#1831)”; “release: OpenMAIC 1.2.0-rc.1 (server-first) (\#1794)”; and 8 more (refs \#1949, \#1831, \#1794, \#1969, \#1879, …).

lib/server/generation/steps · medium confidence · unverified

12 commits (7 fixes) fixing lib/server/generation/run

A fix in lib/server/generation/run — 12 commits (7 fixs), 17 files: “fix(agent): cap parallel generate\_tts calls and keep failure reasons (\#1983)”; “feat: merge PBL v3 and the shared sandbox into main for v1.4.0 (\#2151)”; “fix(pdf): inline image URLs returned by MinerU gateways instead of decoding them as base64 (\#2076)”; and 9 more (refs \#1983, \#2151, \#2076, \#1949, \#1831, …).

lib/server/generation/run · medium confidence · unverified

14 commits (9 fixes) fixing components/workbench

A fix in components/workbench — 14 commits (9 fixs), 15 files: “release: OpenMAIC 1.0.0 — the agent workbench (\#1228)”; “fix(pbl-v3): preserve scroll following in Tests and Quiz (\#2196)”; “fix(persistence): serve the course library without the agent runtime; exit on invalid boot config”; and 11 more (refs \#1228, \#2196, \#2061, \#1794, \#2185, …).

components/workbench · medium confidence · unverified

25 commits (16 fixes) fixing packages/@openmaic/generation/src

A fix in packages/@openmaic/generation/src — 25 commits (16 fixs), 22 files: “fix(agent): cap parallel generate\_tts calls and keep failure reasons (\#1983)”; “fix(generation): assign unique IDs per media request (\#1368)”; “feat(generation): scaffold @openmaic/generation with pipeline types and packaged prompt assets (\#1063)”; and 22 more (refs \#1983, \#1368, \#1063, \#1090, \#1827, …).

packages/@openmaic/generation/src · medium confidence · unverified

4 commits (3 fixes) fixing components

A fix in components — 4 commits (3 fixs), 24 files: “fix(pbl-v3): preserve scroll following in Tests and Quiz (\#2196)”; “feat(edit): course-level undo timeline for manual and agent edits (\#2159)”; “fix(pbl-v3): clarify quiz choices in the task drawer (\#2193)”; and 1 more (refs \#2196, \#2159, \#2193, \#2205). Also in this area: New workbench chat timeline and interaction components.

(repo-wide) · medium confidence · unverified

4 commits (3 fixes) fixing eval/orchestration

A fix in eval/orchestration — 4 commits (3 fixs), 7 files: “fix(agent): respond to the user's turn before lecturing (+ answer-content eval) (\#699)”; “refactor(chat): retire the legacy director-graph classroom chat (\#1913)”; “fix(pi): remove classroom count caps and honor request cancellation (\#2059)”; and 1 more (refs \#699, \#1913, \#2059, \#598, \#599).

eval/orchestration · medium confidence · unverified

Disable formula-defined macros in KaTeX rendering

The math rendering plugin now prevents KaTeX from using formula-defined macros, addressing a security and stability issue where shared state could leak between formulas. A new \safe-math-plugin\ wraps the existing math plugin to replace the KaTeX options with a hardened version that generates a fresh \macros\ object for every render, ensuring that built-in state (such as equation numbering) does not persist across different formulas or messages.

lib/markdown · high confidence

Fix HTML export dropping sibling attributes when style is empty

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 entire attribute list to be dropped during stringification; the fix ensures that only the empty style attribute itself is omitted while keeping other attributes intact.

lib/export/html-parser · high confidence

Fix MathML parsing error in text container detection

Corrects a syntax error in the MathML-to-OMML parser where \includes\ was incorrectly accessed as an array property (\includes\[...\]\) instead of being called as a method. This fix ensures that text container names are properly checked during parsing, preventing runtime errors when processing MathML content.

packages/mathml2omml · high confidence

Fix for line element arrowheads disappearing during thumbnail toggles

The slide renderer now correctly keeps arrowheads visible on line elements when toggling thumbnails. This was achieved by generating unique, stable IDs for SVG markers using React's \useId\ hook, replacing the previous logic that relied on the element's static ID, which caused marker references to break during re-renders or state changes. Additionally, type imports for line elements have been migrated from the local \@/lib/types/slides\ module to the \@openmaic/dsl\ package.

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

New TypeScript PPTX importer with high-fidelity math and robust slide normalization

The \@openmaic/importer\ package now uses a new TypeScript implementation to parse .pptx files, replacing the previous approach. This update introduces high-fidelity math support by converting Equation.3 OLE formulas via MTEF v3 and pre-fetching LaTeX conversion, ensuring complex equations render correctly instead of degrading to placeholders. The importer also normalizes slides at the pipeline output boundary, applying a 'drop' policy for elements that fail DSL normalization to prevent import failures while surfacing warnings for dropped content. Additionally, it preserves tab columns, text insets, arrow rendering, and shape autofit sizes, and handles custom shapes without paths more robustly.

packages/@openmaic/importer/src · high confidence

Test coverage

1 commit adding/updating tests in examples; 30 commits adding/updating tests in packages/@openmaic/generation/test; 9 commits adding/updating tests in packages/@openmaic/generation/test/\_\snapshots\\_; Added contract tests for agent session and asset storage; Added e2e test fixtures for scene generation and model configuration; Added snapshot tests for inline math typesetting and image soft-edge rendering; Added test coverage for chart rendering logic and ECharts integration; Added test coverage for renderer components and utilities; Added test coverage for the OpenMAIC importer pipeline; Added tests for BaseLineElement marker ID stability; Added tests for BaseVideoElement rendering behavior; Added tests for LaTeX element font-metric re-measurement; Added tests for audio and table renderer elements; Added tests for image element rendering and filter handling; Added tests for line geometry bounds and rich text line-break preservation; Added tests for text element rendering and inline math typesetting; Expanded end-to-end test coverage for core user flows and UI behaviors; Initial Playwright end-to-end test page objects for Home, Classroom, and Generation Preview; New Playwright e2e test fixtures for server-backed persistence and generation; Test coverage for ActionEngine, agent runtime, and storage fixtures.

Dependencies

OpenMAIC 1.2.0-rc.1 release with new workspace packages and dependency updates

This release introduces the OpenMAIC 1.2.0-rc.1 version and establishes a new monorepo structure by adding several new workspace packages: @openmaic/dsl (slide DSL contract), @openmaic/editor (slide editing core), @openmaic/generation (generation pipeline), @openmaic/importer (PPTX parsing), @openmaic/renderer (slide rendering), and @openmaic/storage (persistence layer). The root package.json now enforces Node.js \>=22.19.0 and includes new scripts for building packages, running e2e tests with Playwright, and managing database containers. Dependencies have been updated across the board, including Next.js to 16.3.3, React to 19.2.3, and various AI SDK packages, while also adding new dependencies like i18next for internationalization and AWS SDK for S3 storage.

(dependencies) · high confidence

Housekeeping

Enforce Prettier formatting across AI elements components

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 string literals and updated to Prettier's default line-wrapping and indentation rules. This change improves code consistency and readability without altering any component behavior or functionality.

components/ai-elements · high confidence

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

How this codebase got here

Score

  • CAI 47 → 44 (-2.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 58 → 58 (+0.4)
  • Architecture 64 → 65 (+0.6)
  • Maturity 45 → 70 (+25.3)
  • Readiness 46 → 33 (-12.8)
  • Security 65 → 66 (+1.6)
  • Accessibility 44 → 45 (+1.2)
  • Performance 60 → 60 (+0.0)

Resolved (233)

  • Boundary-crossing change coupling: tts-providers.ts ↔ settings.ts (lib/audio/tts-providers.ts)
  • ClassroomSurface.ClassroomSurface (cognitive 81) (components/classroom/ClassroomSurface.tsx)
  • ClassroomSurface.ClassroomSurface (cyclomatic 49) (components/classroom/ClassroomSurface.tsx)
  • Critical vulnerability: [GHSA redacted] (package.json)
  • Cross-context type Action (dsl → generation) (packages/@openmaic/generation/src/action-parser.ts)
  • Cross-context type Action (dsl → generation) (packages/@openmaic/generation/src/scene-builder.ts)
  • Cross-context type Action (dsl → generation) (packages/@openmaic/generation/src/scene-generator.ts)
  • Cross-context type Element (importer → editor) (packages/@openmaic/editor/src/react/text/prosemirror/index.ts)
  • Cross-context type Element (importer → renderer) (packages/@openmaic/renderer/src/elements/chart/clipRepaint.ts)
  • Cross-context type Element (importer → renderer) (packages/@openmaic/renderer/src/utils/inlineMath.ts)
  • Cross-context type Element (importer → renderer) (packages/@openmaic/renderer/src/utils/inlineMath.ts)
  • Cross-context type LinePoint (dsl → editor) (packages/@openmaic/editor/src/ui/insert/LineInsertPicker.tsx)
  • Cross-context type LineStyleType (dsl → editor) (packages/@openmaic/editor/src/ui/insert/LineInsertPicker.tsx)
  • Cross-context type NodeType (importer → editor) (packages/@openmaic/editor/src/react/text/prosemirror/commands/splitListItemInInlineContainer.ts)
  • Cross-context type NodeType (importer → editor) (packages/@openmaic/editor/src/react/text/prosemirror/commands/toggleList.ts)
  • Cross-context type NodeType (importer → editor) (packages/@openmaic/editor/src/react/text/prosemirror/utils.ts)
  • Cross-context type PBLProficiency (dsl → generation) (packages/@openmaic/generation/src/pbl/operations/kernel/proficiency.ts)
  • Cross-context type PBLProficiency (dsl → generation) (packages/@openmaic/generation/src/pbl/operations/kernel/proficiency.ts)
  • Cross-context type PBLProficiency (dsl → generation) (packages/@openmaic/generation/src/pbl/operations/kernel/proficiency.ts)
  • Cross-context type PBLProficiency (dsl → generation) (packages/@openmaic/generation/src/pbl/operations/kernel/proficiency.ts)
  • …and 213 more

New (436)

  • Boundary-crossing change coupling: agent-bar.tsx ↔ use-discussion-tts.ts (components/agent/agent-bar.tsx)
  • Boundary-crossing change coupling: page.tsx ↔ agent-bar.tsx (app/generation-preview/page.tsx)
  • ClassTooLong: LearningStore (lib/server/pbl-v3/store.ts)
  • ClassTooLong: PgAssetStore (packages/@openmaic/storage/src/asset/pg.ts)
  • ClassroomSurface.ClassroomSurfaceContent (cognitive 74) (components/classroom/ClassroomSurface.tsx)
  • ClassroomSurface.ClassroomSurfaceContent (cyclomatic 47) (components/classroom/ClassroomSurface.tsx)
  • Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
  • Critical vulnerability: [GHSA redacted] (package.json)
  • Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (registry.npmjs.org unreachable)
  • Documentation: no build, run or usage example (packages/@openmaic/generation/README.md)
  • FetchEventSource.connect (cognitive 23) (lib/utils/fetch-event-source.ts)
  • FetchEventSource.connect (cyclomatic 18) (lib/utils/fetch-event-source.ts)
  • FileTooLong: asset/collector.ts (packages/@openmaic/storage/src/asset/collector.ts)
  • FileTooLong: course-edit/apply.ts (lib/server/agent-runtime/course-edit/apply.ts)
  • FileTooLong: generation/step-visualizers.tsx (components/generation/step-visualizers.tsx)
  • FileTooLong: orchestration/transition.ts (lib/pbl/v3/domain/orchestration/transition.ts)
  • FileTooLong: pbl-v3/project-package.ts (lib/server/pbl-v3/project-package.ts)
  • FileTooLong: pbl-v3/report.ts (lib/server/pbl-v3/report.ts)
  • FileTooLong: pbl-v3/runner-tools.ts (lib/server/pbl-v3/runner-tools.ts)
  • FileTooLong: pbl-v3/runtime.ts (lib/server/pbl-v3/runtime.ts)
  • …and 416 more

Changes since last survey

  • 116 commits — 39 feature/other, 77 fixes

By area

  • lib/server — 16 commits
  • (root) — 14 commits
  • .github/workflows — 9 commits
  • lib/i18n — 8 commits
  • packages/@openmaic — 8 commits
  • components/workbench — 6 commits
  • packages/docs — 4 commits
  • tests/workbench — 4 commits
  • e2e/tests — 3 commits
  • lib/pbl — 3 commits
  • .github/scripts — 2 commits
  • components/edit — 2 commits
  • components/scene-renderers — 2 commits
  • lib/ai — 2 commits
  • lib/export — 2 commits
  • lib/prosemirror — 2 commits
  • tests/agent-runtime — 2 commits
  • tests/lib — 2 commits
  • tests/pbl — 2 commits
  • tests/persistence — 2 commits

Notable commits

  • fix: fix(agent): cap parallel generate_tts calls and keep failure reasons (#1983)
  • fix: fix(agent): clarify newline escaping in course edits and diagnostics (#2152)
  • fix: fix(agent): declare generate_scene widgetOutline as an object (#2157)
  • fix: fix(agent): recover conversations after personal Skill deletion (#2086)
  • fix: fix(agent-runtime): keep the system prompt stable when materials change (#2027)
  • fix: fix(agent-runtime): make course tools easier for the agent to address and read (#1999)
  • fix: fix(agent-runtime): make patch_stage robust to legacy data and self-correcting on errors (#2000)
  • fix: fix(agent-runtime): send self-contained scenes to the render preview and surface its refusal reason (#2082)
  • fix: fix(agent-runtime): unify capability-dependent tool registration (#2118)
  • fix: fix(agent-skills): tighten course agent reporting and completion guidance (#1998)
  • fix: fix(ai): send generic thinking toggle for uncatalogued models (#2190)
  • fix: fix(asr): support compatible transcription formats (#2032)
  • fix: fix(audio): follow the interface locale for default speech languages (#1935)
  • fix: fix(audio): migrate Qwen voice cloning to CosyVoice (#1949)
  • fix: fix(audio): prevent classroom resume from stalling after narration failure (#2110)
  • fix: fix(audio): stop the TTS timeout hint from driving retry loops (#2149)
  • fix: fix(classroom): use the course's own roster when the classroom loads (#2136)
  • fix: fix(editor): defer narration markers until local audio is checked (#1985)
  • fix: fix(editor): keep inline formulas when legacy canvas text is edited (#2018)
  • fix: fix(editor): keep legacy narration markers stable across edits (#1953)
  • …and 96 more

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 5bd8cc840ee6397d063e1fe6aba974b9f0401593 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-110e4fee044f.