What's new in Scheduler Pro v7.3.0

AI feature enhancements

The experimental AI feature introduced in 7.2.0 has been enhanced with new tools for the agent:

Time range context selector

The AI chat panel now includes a time range context chip displayed below the message input. It shows the currently active range (Timeline, In view, or All) and lets users quickly switch between them by clicking the chip or pressing Space/Enter when focused. This controls which data is sent to the AI agent as context, without needing to open the settings panel.

The default range is still configured via the defaultRange config in settings, but the chip allows temporary overrides during a session.

Column visibility management

The agent now supports showing and hiding columns. Users can ask the agent to show or hide specific columns in the grid, for example "hide the age column" or "show all hidden columns". The agent uses three new tools internally:

• getColumns – Reads the available columns and their current visibility state
• showColumn – Shows a hidden column
• hideColumn – Hides a visible column

The show/hide tools are only made available to the LLM after columns have been read, ensuring the agent always has accurate column information before making changes.

Token usage tracking

The AI feature now tracks token usage for each API response. Every AI message record stores inputTokens, outputTokens, and totalTokens, making it easy to monitor API consumption programmatically. When debugMode is enabled, each API call logs current and cumulative token usage to the browser console.

Structured tool responses

AI tool call responses now use a structured AIToolCallResult format internally ({ ok, message, data, error }). Tool functions can return either a plain string (wrapped as { ok: true, message }) or a AIToolCallResult object. Each API plugin (OpenAI, Anthropic, Google) converts this internal format to its native representation automatically.

New static helpers on AIHelper make it easy to create structured responses:

• AIHelper.error('message') – Creates an error response ({ ok: false, error: { message } })
• AIHelper.result(data, message?) – Creates a success response with a data payload ({ ok: true, data })

Async status messages

The AI chat bubble now shows contextual status messages throughout the entire prompt lifecycle. When a prompt is sent, the bubble shows "Thinking". During tool calls, it shows tool-specific messages like "Reading Records", "Updating Records", "Removing Records", "Adding Record", or "Filtering Records". After tool calls complete and responses are sent back to the LLM, it shows "Processing". A queue-based system ensures each status message is visible for a minimum time (minStatusDisplayTime, default 400ms) before the next one appears. The existing delay status texts ("Waiting", "Still waiting", etc.) continue to cycle when responses take longer than 3 seconds.

Inline confirmation dialogs

The AI feature's confirmation dialogs now render inline within the chat panel instead of as floating modal popups. This provides a more integrated experience where confirmations appear naturally in the conversation flow. The dialog automatically scrolls into view and supports responsive button labels via CSS container queries. When no chat panel is visible (e.g. voice-only mode), the dialog still falls back to a floating modal popup.

Ask user tool

The agent can now present the user with a set of clickable options when it needs a decision before proceeding. For example, when a request is ambiguous the agent can ask the user to pick from a list of choices. After the user selects an option, the conversation continues with a new response based on the selection.

Voice conversation improvements

The AI chat panel's voice conversation mode has been improved:

• Stop button for read-aloud – The stop button now remains visible and functional while the AI response is being read aloud, regardless of whether the read-aloud was triggered manually or automatically via autoReadAloud. Clicking stop interrupts the speech playback immediately.
• Stop audio on panel close – When the chat panel is closed, any ongoing recording and audio playback is automatically stopped. This behavior is controlled by the new stopAudioOnHide config (enabled by default).
• The autoRecord config now defaults to false.

Grouping

The agent can now group records by a field when the Group feature is enabled. Users can ask the agent to group data, for example "group by city" or "clear the grouping". Calling the tool without a field parameter clears all active groupers.

Planning tools

The AI agent can now break complex multi-step requests into a tracked plan, improving reliability — especially with smaller or less capable LLM models. When a user request requires several sequential actions (for example, "copy this event to every day of the week"), the agent creates a plan with individual steps, executes each one, and tracks progress.

Two new tools power this:

• createPlan – Outlines the steps needed to fulfill a multi-step request
• completePlanSteps – Marks steps as completed after executing the corresponding tool calls

Planning is enabled by default via the new planning config and can be toggled from the AI settings panel at runtime:

new SchedulerPro({
    features : {
        ai : {
            planning : false  // Disable planning tools
        }
    }
});

@ Mention support

The AI chat input now supports @ mentions for referencing data records directly in messages. Typing @ followed by at least one character searches the configured data models by their classDisplayName and shows a dropdown of matching records. The dropdown aligns to the @ character position and supports keyboard navigation (ArrowDown/ArrowUp), Enter/Tab to select, Escape to dismiss, and click selection.

When a message is sent, the field value contains structured tokens like {@:"Record Name", model:"ModelName", id:123} that the agent can interpret. Chat bubbles automatically detect and render these tokens as styled mention tags — both in local messages and in LLM responses that reference the same token format. Pasted content is sanitized to plain text.

The feature is enabled by default and can be disabled:

new SchedulerPro({
    features : {
        ai : {
            mentions : false,  // Disable @ mentions
            // ...
        }
    }
});

Prompt history

The AI chat panel supports ArrowUp/ArrowDown to cycle through previously sent messages. This was previously always enabled and automatically persisted to localStorage. It is now opt-in via the promptHistory config on the AI feature. Pass an array of strings (e.g. loaded from localStorage) to enable it, and listen to the promptHistoryUpdate event to persist changes:

new SchedulerPro({
    features : {
        ai : {
            promptHistory : JSON.parse(localStorage.getItem('prompt-history') || '[]'),
            listeners : {
                promptHistoryUpdate({ promptHistory }) {
                    localStorage.setItem('prompt-history', JSON.stringify(promptHistory));
                }
            }
        }
    }
});

When the field contains multiline text, ArrowUp/ArrowDown move the cursor between lines instead of navigating history. History navigation only activates when the cursor is on the first or last line and the field content has not been manually edited.

Smooth zooming

Scheduler Pro now supports smooth, continuous zooming instead of jumping between discrete preset levels. When enabled, the zoom system interpolates between view presets, creating a fluid experience similar to map applications. This works with mouse wheel, trackpad pinch gestures, and programmatic zoom calls.

To enable it, set the smoothZoom config to true:

const schedulerPro = new SchedulerPro({
    smoothZoom : true
});

You can also add the new TimeZoomSlider widget to a toolbar for visual zoom control:

const schedulerPro = new SchedulerPro({
    smoothZoom : true,
    tbar : [
        { type : 'timezoomslider' }
    ]
});

Programmatic zoom calls support animation for smooth transitions:

await schedulerPro.zoomIn({ animate : true });
await schedulerPro.zoomToFit({ animate : true });

Try it out below - use the slider or scroll wheel to zoom:

ResourceHistogram and ResourceUtilization improvements

The base class for ResourceHistogram and ResourceUtilization has been refactored to enhance performance and improve UX. The following improvements have been made:

• ResourceHistogram and ResourceUtilization series can now be disabled and enabled via the disabled flag on series records. When toggled, the series hides or shows with a smooth animation. Previously, hiding a series required using CSS display:none.
• Data changes in histogram bars now animate smoothly, providing visual continuity when values update.
• ResourceHistogram and ResourceUtilization now use a single shared SVG canvas (<svg>) overlaying the time axis instead of rendering one SVG per row. This significantly improves performance for large datasets.

EventDrag feature changes

New Scheduler Pro subclass

Scheduler Pro now has its own EventDrag feature, subclassing the feature from the basic Scheduler. All Pro related code was moved to the new feature. The change will not require any changes in your application code, unless you are using SchedulerProBase, in which case you will need to import the new feature instead of the one from Scheduler.

New updateRecordsFn config

The feature introduces a new public updateRecordsFn config that can be used for customizing applying changes to the dragged events:

new SchedulerPro({
    features : {
        eventDrag : {
            // customize event changes applying
            async updateRecordsFn({ eventRecords, timeDiff }) {
                const { project } = this.client;

                // for each dragged event
                eventRecords.forEach(event => {
                    const
                        { startDate, predecessors } = event,
                        newStartDate                = new Date(startDate.getTime() + timeDiff);

                    // if the event has predecessors we are going to adjust their lag values
                    if (startDate && predecessors.length) {
                        // for each predecessor
                        for (const predecessor of event.predecessors) {
                            const
                                predecessorEndDate = predecessor.fromEvent.endDate,
                                // calculate new lag in predecessor's lag unit
                                newLag = event.run('convertDurationGen', newStartDate - predecessorEndDate, 'ms', predecessor.lagUnit);

                            predecessor.lag = newLag;
                        }
                    }

                    // move the event
                    event.startDate = newStartDate;
                });

                await project.commitAsync();
            }
        }
    }

})

New constrainDragByEngine config

The feature introduces a new constrainDragByEngine config that controls how Engine constraints are applied to the dragged task dates - whether they should be adjusted according to the task (and its parents) constraints and dependencies. This doesn't affect the effective task dates which are always calculated based on corresponding restrictions but only affects "raw" dates calculated while dragging.

Providing true to the config enables constraining by both constraints and dependencies and providing false disables them.

Use an object to enable constraining by constraints or dependencies:

new SchedulerPro({
    ...
    features : {
        eventDrag : {
            constrainDragByEngine : {
                // honor dependencies but ignore constraints
                dependencies : true,
                constraints  : false
            }
        }
    }
});