Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.
JavaScript agent-collaborationagent-harnessagent-orchestrationagent-teamagent-workflowai-assistantai-automationai-employeeai-productivityai-teamai-workflowautonomous-agentsclaude-code-guiclaude-coworkdesktop-agentlocal-firstmulti-agentmulti-agent-systemself-evolving-agentstask-automation
// ─── Shared composer model picker ─────────────────────────────────────────
// Every model-backed composer exposes the same locally configured priority
// list. Picking an entry moves it to the front; credentials and drag ordering
// remain owned by Settings > Models.
let _composerModelEntries = [];
let _composerModelEntriesEpoch = 0;
let _composerModelMenu = null;
let _composerModelOpening = null;
let _composerModelBusy = false;
let _composerModelOptionsByProvider = new Map();
const _composerModelLog = createLogger('composer-model-picker');
const _COMPOSER_MODEL_PICKER_TARGETS = [
{ selector: '#panel-new-chat .chat-bottom-bar', target: 'new-chat' },
{ selector: '#panel-conversation .chat-bottom-bar', target: 'conversation' },
{ selector: '#panel-project .chat-bottom-bar', target: 'project' },
{ selector: '#auto-task-dialog-overlay .chat-bottom-bar', target: 'auto' },
{ selector: '#skills-chat-col .skills-chat-input-area', target: 'skill-edit', compact: true },
{ selector: '#agents-chat-col .agents-chat-input-area', target: 'agent-edit', compact: true },
];
const _COMPOSER_RECIPIENT_TARGETS = ['new-chat', 'conversation', 'project', 'auto'];
/** Keep the three composer-level pickers mutually exclusive. Their anchors
* stop click propagation, so independent outside-click listeners cannot close
* a picker when another composer control opens. Centralizing that transition
* also keeps every anchor's visual/ARIA open state in sync with its panel. */
function _closeOtherComposerPopovers(activeKind) {
if (activeKind !== 'model' && typeof _closeComposerModelMenu === 'function') {
_closeComposerModelMenu();
}
if (activeKind !== 'recipient' && typeof _closeAgentPicker === 'function') {
_closeAgentPicker();
}
if (activeKind !== 'workspace') {
const workspaceMenu = document.getElementById('workspace-menu');
if (workspaceMenu) {
if (typeof workspaceMenu._closeWorkspaceMenu === 'function') {
workspaceMenu._closeWorkspaceMenu();
} else {
workspaceMenu.remove();
}
}
}
}
function _composerRecipientForTarget(target) {
try {
if (target === 'auto') {
return typeof window._autoGetRecipient === 'function'
? window._autoGetRecipient()
: null;
}
return typeof getChatRecipient === 'function'
? getChatRecipient(target)
: null;
} catch (_) {
return null;
}
}
function _composerRecipientUsesExternalAgent(target) {
if (typeof _agentsCache === 'undefined' || !Array.isArray(_agentsCache)) return false;
// A planned send (D29) is split by a model call even when every mentioned
// actor is a CLI agent, so the model choice still applies.
if (target !== 'auto' && typeof _composerSendIsPlanned === 'function'
&& typeof _composerRecipientInput === 'function' && typeof composerText === 'function') {
const input = _composerRecipientInput(target);
if (input && _composerSendIsPlanned(composerText(input) || '', target)) return false;
}
const preview = target !== 'auto' && _COMPOSER_RECIPIENT_TARGETS.includes(target)
&& typeof _mentionPreviewRecipients === 'function'
? _mentionPreviewRecipients(target)
: [];
const selected = _composerRecipientForTarget(target);
const recipients = preview.length ? preview : selected?.kind === 'group' ? selected.recipients : [selected];
return recipients.every((recipient) => {
if (!recipient || recipient.kind !== 'agent' || !recipient.id) return false;
const agent = _agentsCache.find((item) => item && item.agent_id === recipient.id);
return !!(agent && agent.runtime && agent.runtime.kind === 'cli');
});
}
function _syncComposerModelChipAvailability(target) {
const targets = target ? [target] : _COMPOSER_RECIPIENT_TARGETS;
targets.forEach((item) => {
const chip = document.querySelector(`[data-composer-model-chip="${item}"]`);
if (!chip) return;
const disabled = _composerRecipientUsesExternalAgent(item);
if (disabled && _composerModelMenu?.anchor === chip) _closeComposerModelMenu();
chip.disabled = disabled;
chip.hidden = false;
});
}
function _composerModelEntryLabel(entry) {
if (_composerModelEntryIsOfficial(entry)) {
const officialModelName = String((entry && (entry.modelName || entry.model)) || '').trim();
if (officialModelName) return officialModelName;
}
const model = String((entry && (entry.modelName || entry.model)) || '');
const modelName = model
.split(/\s*·\s*/)
.map((part) => part.trim())
.filter(Boolean)
.pop();
return modelName
|| String((entry && entry.profileLabel) || '')
|| t('new_chat.model_picker.configure');
}
function _composerModelEntryIsOfficial(entry) {
return !!entry && entry.official === true && entry.provider === 'orkas-api';
}
function _composerModelMenuGroups(entries) {
const list = Array.isArray(entries) ? entries : [];
return [
{
key: 'official',
labelKey: 'new_chat.model_picker.group_official',
entries: list.filter(_composerModelEntryIsOfficial),
},
{
key: 'custom',
labelKey: 'new_chat.model_picker.group_custom',
entries: list.filter((entry) => !_composerModelEntryIsOfficial(entry)),
},
].filter((group) => group.entries.length > 0);
}
function _composerModelProviderLabel(entry) {
const labelKey = String((entry && entry.providerLabelKey) || '').trim();
if (labelKey) return t(labelKey);
return String((entry && (entry.providerLabel || entry.provider)) || '').trim();
}
function _composerModelAccountLabel(entry) {
return [
_composerModelProviderLabel(entry),
String((entry && entry.profileLabel) || '').trim(),
].filter(Boolean).join(' · ');
}
function _createComposerModelChip(target, compact) {
const chip = document.createElement('button');
chip.type = 'button';
chip.className = `composer-model-chip${compact ? ' is-compact' : ''}`;
chip.dataset.composerModelChip = target;
chip.setAttribute('aria-haspopup', 'menu');
chip.setAttribute('aria-expanded', 'false');
chip.innerHTML = `
<span class="composer-model-chip-name">${escapeHtml(t('new_chat.model_picker.loading'))}</span>
${typeof window.uiIconHtml === 'function' ? window.uiIconHtml('chevron-down', 'composer-model-chip-chevron') : ''}
`;
chip.addEventListener('click', () => _toggleComposerModelMenu(chip));
return chip;
}
function _mountComposerModelChips() {
for (const spec of _COMPOSER_MODEL_PICKER_TARGETS) {
const container = document.querySelector(spec.selector);
if (!container) continue;
const chip = container.querySelector(`[data-composer-model-chip="${spec.target}"]`)
|| _createComposerModelChip(spec.target, !!spec.compact);
const recipient = container.querySelector('.chat-recipient-chip');
if (recipient) {
container.insertBefore(chip, recipient);
continue;
}
const input = container.querySelector('textarea');
if (input) {
container.insertBefore(chip, input);
continue;
}
container.appendChild(chip);
}
_renderComposerModelChips();
}
function _renderComposerModelChips() {
const first = _composerModelEntries.find((entry) => entry && entry.selectable !== false);
const label = first
? _composerModelEntryLabel(first)
: t('new_chat.model_picker.configure');
document.querySelectorAll('[data-composer-model-chip]').forEach((chip) => {
const name = chip.querySelector('.composer-model-chip-name');
if (name) name.textContent = label;
chip.title = `${t('new_chat.model_picker.aria_label')}: ${label}`;
chip.setAttribute('aria-label', `${t('new_chat.model_picker.aria_label')}: ${label}`);
});
_syncComposerModelChipAvailability();
}
async function _refreshComposerModelEntries() {
const epoch = ++_composerModelEntriesEpoch;
try {
const res = await window.orkas.invoke('auth.listComposerEntries');
if (epoch === _composerModelEntriesEpoch && res && res.ok && Array.isArray(res.entries)) {
_composerModelEntries = res.entries.filter((entry) => entry && entry.profileType !== 'managed');
}
} catch (_) {
// Keep the previous snapshot. The model guard owns global error handling.
}
_renderComposerModelChips();
return _composerModelEntries;
}
function _composerModelVersionOptions(entry) {
const models = _composerModelOptionsByProvider.get(String((entry && entry.provider) || ''));
const options = Array.isArray(models)
? models
.filter((model) => model && typeof model.id === 'string' && model.id.trim())
.map((model) => ({ id: model.id, name: String(model.name || model.id) }))
: [];
if (entry && !_composerModelEntryIsOfficial(entry) && entry.model
&& !options.some((model) => model.id === entry.model)) {
options.unshift({ id: entry.model, name: _composerModelEntryLabel(entry) });
}
return options;
}
async function _refreshComposerModelOptions(entries) {
const providers = Array.from(new Set((Array.isArray(entries) ? entries : [])
.filter((entry) => (
entry
&& !_composerModelEntryIsOfficial(entry)
&& entry.modelEditable !== false
&& entry.selectable !== false
&& entry.provider
))
.map((entry) => String(entry.provider))));
const results = await Promise.all(providers.map(async (provider) => {
try {
const res = await window.orkas.invoke('auth.listModels', { provider });
return [provider, res && res.ok && Array.isArray(res.models) ? res.models : []];
} catch (_) {
_composerModelLog.warn('model version discovery failed', { provider });
return [provider, []];
}
}));
_composerModelOptionsByProvider = new Map(results);
}
function _closeComposerModelMenu() {
_composerModelOpening = null;
if (!_composerModelMenu) return;
_closeComposerModelVersionMenu();
const {
element,
anchor,
onOutside,
onKeydown,
onViewportChange,
} = _composerModelMenu;
element.remove();
document.removeEventListener('mousedown', onOutside);
document.removeEventListener('keydown', onKeydown);
window.removeEventListener('resize', onViewportChange);
window.removeEventListener('scroll', onViewportChange, true);
anchor.classList.remove('is-open');
anchor.setAttribute('aria-expanded', 'false');
_composerModelMenu = null;
}
function _clearComposerModelVersionCloseTimer() {
if (!_composerModelMenu || !_composerModelMenu.versionCloseTimer) return;
clearTimeout(_composerModelMenu.versionCloseTimer);
_composerModelMenu.versionCloseTimer = null;
}
function _closeComposerModelVersionMenu({ focusOwner = false } = {}) {
if (!_composerModelMenu) return;
_clearComposerModelVersionCloseTimer();
const { versionMenu, versionOwner } = _composerModelMenu;
versionOwner?.classList.remove('is-version-open');
const versionTrigger = versionOwner?.querySelector('.composer-model-menu-disclosure');
versionTrigger?.setAttribute('aria-expanded', 'false');
versionMenu?.remove();
_composerModelMenu.versionMenu = null;
_composerModelMenu.versionOwner = null;
if (focusOwner) versionTrigger?.focus();
}
function _scheduleComposerModelVersionMenuClose() {
if (!_composerModelMenu) return;
_clearComposerModelVersionCloseTimer();
const menuState = _composerModelMenu;
menuState.versionCloseTimer = setTimeout(() => {
if (_composerModelMenu === menuState) _closeComposerModelVersionMenu();
}, 120);
}
function _positionComposerModelMenu(menu, anchor) {
const edge = 8;
const gap = 7;
const viewportWidth = window.innerWidth || document.documentElement.clientWidth;
const viewportHeight = window.innerHeight || document.documentElement.clientHeight;
const anchorRect = anchor.getBoundingClientRect();
menu.style.maxHeight = '';
const menuRect = menu.getBoundingClientRect();
const fullHeight = Math.max(menuRect.height, menu.scrollHeight || 0);
const placement = _dropdownVerticalPlacement(
anchorRect,
fullHeight,
viewportHeight,
{ edge, gap },
);
const left = Math.max(
edge,
Math.min(anchorRect.right - menuRect.width, viewportWidth - menuRect.width - edge),
);
menu.style.left = `${left}px`;
menu.style.top = `${placement.top}px`;
menu.style.maxHeight = `${placement.availableHeight}px`;
menu.dataset.placement = placement.openAbove ? 'top' : 'bottom';
}
function _composerModelCascadePlacement(ownerRect, menuSize, viewportWidth, viewportHeight) {
const edge = 8;
const gap = 5;
const width = Math.min(menuSize.width, Math.max(0, viewportWidth - (edge * 2)));
const maxHeight = Math.max(0, viewportHeight - (edge * 2));
const visibleHeight = Math.min(menuSize.height, maxHeight);
const rightLeft = ownerRect.right + gap;
const leftLeft = ownerRect.left - gap - width;
const openLeft = rightLeft + width > viewportWidth - edge && leftLeft >= edge;
const preferredLeft = openLeft ? leftLeft : rightLeft;
return {
left: Math.max(edge, Math.min(preferredLeft, viewportWidth - width - edge)),
top: Math.max(edge, Math.min(ownerRect.top, viewportHeight - visibleHeight - edge)),
maxHeight,
openLeft,
};
}
function _positionComposerModelVersionMenu(versionMenu, owner) {
if (!versionMenu || !owner) return;
versionMenu.style.maxHeight = '';
const rect = versionMenu.getBoundingClientRect();
const placement = _composerModelCascadePlacement(
owner.getBoundingClientRect(),
{ width: rect.width, height: Math.max(rect.height, versionMenu.scrollHeight || 0) },
window.innerWidth || document.documentElement.clientWidth,
window.innerHeight || document.documentElement.clientHeight,
);
versionMenu.style.left = `${placement.left}px`;
versionMenu.style.top = `${placement.top}px`;
versionMenu.style.maxHeight = `${placement.maxHeight}px`;
versionMenu.dataset.placement = placement.openLeft ? 'left' : 'right';
}
function _openComposerModelVersionMenu(owner, versionMenu, { focusFirst = false } = {}) {
if (!_composerModelMenu || !owner || !versionMenu) return;
_clearComposerModelVersionCloseTimer();
if (_composerModelMenu.versionMenu !== versionMenu) {
_closeComposerModelVersionMenu();
_composerModelMenu.versionMenu = versionMenu;
_composerModelMenu.versionOwner = owner;
versionMenu.style.visibility = 'hidden';
document.body.appendChild(versionMenu);
}
owner.classList.add('is-version-open');
owner.querySelector('.composer-model-menu-disclosure')?.setAttribute('aria-expanded', 'true');
_positionComposerModelVersionMenu(versionMenu, owner);
versionMenu.style.visibility = '';
if (focusFirst) versionMenu.querySelector('button')?.focus();
}
async function _selectComposerModel(entry) {
if (_composerModelBusy || !entry || !entry.entryId || entry.selectable === false) return;
const requestedModel = String(entry.model || '').trim();
const activeEntry = _composerModelEntries.find((candidate) => (
candidate && candidate.selectable !== false
));
if (
activeEntry
&& activeEntry.entryId === entry.entryId
&& (!requestedModel || requestedModel === String(activeEntry.model || '').trim())
) return;
_composerModelBusy = true;
const previousEntries = _composerModelEntries.slice();
try {
const res = await window.orkas.invoke('auth.selectEntry', {
entryId: entry.entryId,
...(requestedModel ? { model: requestedModel } : {}),
});
if (!res || !res.ok) throw new Error('model reorder failed');
_composerModelEntries = Array.isArray(res.entries)
? res.entries.filter((item) => item && item.profileType !== 'managed')
: [
entry,
...previousEntries.filter((item) => item.entryId !== entry.entryId),
];
_renderComposerModelChips();
try {
window.dispatchEvent(new CustomEvent('orkas:model-entries-changed', {
detail: { entries: _composerModelEntries },
}));
} catch (_) {}
} catch (_) {
if (typeof uiToast === 'function') {
uiToast(t('new_chat.model_picker.switch_failed'), { variant: 'error' });
}
} finally {
_composerModelBusy = false;
}
}
function _setComposerModelVersionItemCurrent(item, current) {
if (!item) return;
item.setAttribute('aria-checked', current ? 'true' : 'false');
item.classList.toggle('is-current', current);
const existingDot = item.querySelector('.composer-model-menu-version-current-dot');
if (current && !existingDot) {
const dot = document.createElement('span');
dot.className = 'composer-model-menu-version-current-dot';
dot.textContent = '●';
dot.setAttribute('aria-hidden', 'true');
item.appendChild(dot);
} else if (!current) {
existingDot?.remove();
}
}
async function _updateComposerModelVersion(entry, _target, version, item, versionList) {
if (_composerModelBusy || !entry || !entry.entryId || entry.selectable === false || !version) return;
const requestedModel = String(version.id || '').trim();
if (!requestedModel || requestedModel === String(entry.model || '').trim()) return;
_composerModelBusy = true;
try {
const res = await window.orkas.invoke('auth.updateEntryModel', {
entryId: entry.entryId,
model: requestedModel,
});
if (!res || !res.ok) throw new Error('model version update failed');
const modelName = String(version.name || requestedModel);
entry.model = requestedModel;
entry.modelName = modelName;
const index = _composerModelEntries.findIndex((candidate) => candidate.entryId === entry.entryId);
if (index >= 0) {
_composerModelEntries[index] = { ..._composerModelEntries[index], model: requestedModel, modelName };
}
item?.querySelector('.composer-model-menu-current-model')?.replaceChildren(modelName);
versionList?.querySelectorAll('.composer-model-menu-version-item').forEach((versionItem) => {
_setComposerModelVersionItemCurrent(versionItem, versionItem.dataset.model === requestedModel);
});
_renderComposerModelChips();
try {
window.dispatchEvent(new CustomEvent('orkas:model-entries-changed', {
detail: { entries: _composerModelEntries },
}));
} catch (_) {}
} catch (err) {
_composerModelLog.warn('model version update failed', {
error_type: err && typeof err.name === 'string' ? err.name : 'unknown',
});
if (typeof uiToast === 'function') {
uiToast(t('new_chat.model_picker.switch_failed'), { variant: 'error' });
}
} finally {
_composerModelBusy = false;
}
}
function _openComposerModelSettings() {
_closeComposerModelMenu();
if (typeof _hideAutoDialog === 'function') _hideAutoDialog();
if (typeof _markBootUserNavigation === 'function') _markBootUserNavigation();
setView('settings', null, { entryPoint: 'composer_model_picker' });
if (typeof _activateModelCredentialsTab === 'function') _activateModelCredentialsTab();
}
function _composerModelOfficialIncludedBody(entry) {
const included = _composerModelEntryIsOfficial(entry) && Array.isArray(entry.includedModels)
? entry.includedModels.filter((item) => typeof item === 'string' && item.trim())
: [];
return included.join(' · ');
}
function _composerModelOfficialDescription(entry) {
if (!_composerModelEntryIsOfficial(entry)) return '';
const configured = String((entry && entry.description) || '').trim();
if (configured) return configured;
let key = '';
if (entry.model === 'orkas-llm-1.5') {
key = 'new_chat.model_picker.official_standard_description';
} else if (entry.model === 'orkas-llm-1.5-pro') {
key = 'new_chat.model_picker.official_pro_description';
}
if (!key) return '';
const taskDescription = t(key);
const included = _composerModelOfficialIncludedBody(entry);
return included
? t('new_chat.model_picker.official_detail', {
description: taskDescription,
includes: t('new_chat.model_picker.includes', { models: included }),
})
: taskDescription;
}
function _buildComposerModelMenuItem(entry, activeEntryId, anchor) {
const isActive = entry.entryId === activeEntryId;
const item = document.createElement('div');
item.className = `composer-model-menu-item${isActive ? ' is-active' : ''}`;
item.dataset.entryId = entry.entryId;
const disabled = entry.selectable === false;
if (disabled) item.classList.add('is-disabled');
const select = document.createElement('button');
select.type = 'button';
select.className = 'composer-model-menu-select';
select.setAttribute('role', 'menuitemradio');
select.setAttribute('aria-checked', isActive ? 'true' : 'false');
select.disabled = disabled;
select.setAttribute('aria-disabled', disabled ? 'true' : 'false');
const official = _composerModelEntryIsOfficial(entry);
const copy = document.createElement('span');
copy.className = 'composer-model-menu-copy';
const title = document.createElement('span');
title.className = 'composer-model-menu-title';
const titleName = document.createElement('span');
titleName.className = 'composer-model-menu-title-name';
titleName.textContent = official
? _composerModelEntryLabel(entry)
: (_composerModelProviderLabel(entry) || _composerModelEntryLabel(entry));
title.appendChild(titleName);
const hasSavings = official && entry.model === 'orkas-llm-1.5';
if (official && entry && (entry.recommended === true || hasSavings)) {
const recommended = document.createElement('span');
recommended.className = 'composer-model-menu-recommended';
recommended.textContent = hasSavings
? t('new_chat.model_picker.recommended_with_savings')
: t('new_chat.model_picker.recommended');
title.appendChild(recommended);
}
copy.appendChild(title);
const officialDescription = _composerModelOfficialDescription(entry);
const account = official
? _composerModelOfficialIncludedBody(entry)
: String((entry && entry.profileLabel) || '').trim();
const currentModelName = official ? '' : _composerModelEntryLabel(entry);
if (officialDescription) {
const description = document.createElement('span');
description.className = 'composer-model-menu-description';
description.textContent = officialDescription;
copy.appendChild(description);
}
if ((account || currentModelName) && !officialDescription) {
const meta = document.createElement('span');
meta.className = 'composer-model-menu-meta';
if (official) {
meta.textContent = t('new_chat.model_picker.includes', { models: account });
} else {
if (account) {
const accountLabel = document.createElement('span');
accountLabel.className = 'composer-model-menu-account-label';
accountLabel.textContent = account;
meta.appendChild(accountLabel);
}
if (account && currentModelName) {
const separator = document.createElement('span');
separator.className = 'composer-model-menu-meta-separator';
separator.textContent = ' · ';
meta.appendChild(separator);
}
if (currentModelName) {
const modelLabel = document.createElement('span');
modelLabel.className = 'composer-model-menu-current-model';
modelLabel.textContent = currentModelName;
meta.appendChild(modelLabel);
}
}
copy.appendChild(meta);
}
if (disabled) {
const state = document.createElement('span');
state.className = 'composer-model-menu-state';
state.textContent = entry.availability === 'user_disabled'
? t('new_chat.model_picker.disabled')
: (String(entry.availabilityReason || '').trim().slice(0, 200)
|| t('new_chat.model_picker.unavailable'));
copy.appendChild(state);
}
select.appendChild(copy);
if (isActive) {
const check = document.createElement('span');
check.className = 'composer-model-menu-check';
check.innerHTML = typeof window.uiIconHtml === 'function'
? window.uiIconHtml('check', 'ui-icon')
: '✓';
select.appendChild(check);
}
select.addEventListener('click', async () => {
if (disabled) return;
_closeComposerModelMenu();
await _selectComposerModel(entry);
anchor.focus();
});
item.appendChild(select);
const versions = !official && entry.modelEditable !== false
? _composerModelVersionOptions(entry)
: [];
if (!disabled && versions.length > 1) {
const disclosure = document.createElement('button');
disclosure.type = 'button';
disclosure.className = 'composer-model-menu-disclosure';
disclosure.innerHTML = typeof window.uiIconHtml === 'function'
? window.uiIconHtml('chevron-right', 'ui-icon')
: '›';
disclosure.setAttribute('role', 'menuitem');
disclosure.setAttribute('aria-haspopup', 'menu');
disclosure.setAttribute('aria-expanded', 'false');
disclosure.setAttribute('aria-label', t('new_chat.model_picker.choose_version', {
account: _composerModelAccountLabel(entry) || _composerModelEntryLabel(entry),
}));
item.appendChild(disclosure);
const versionList = document.createElement('div');
versionList.className = 'composer-model-menu-version-list';
versionList.dataset.entryId = entry.entryId;
versionList.setAttribute('role', 'menu');
versionList.setAttribute('aria-label', t('new_chat.model_picker.version_list', {
account: _composerModelAccountLabel(entry) || _composerModelEntryLabel(entry),
}));
versions.forEach((version) => {
const versionItem = document.createElement('button');
versionItem.type = 'button';
versionItem.className = 'composer-model-menu-version-item';
versionItem.dataset.model = version.id;
versionItem.setAttribute('role', 'menuitemradio');
const current = version.id === entry.model;
versionItem.setAttribute('aria-checked', current ? 'true' : 'false');
const label = document.createElement('span');
label.className = 'composer-model-menu-version-label';
label.textContent = version.name;
versionItem.appendChild(label);
_setComposerModelVersionItemCurrent(versionItem, current);
versionItem.addEventListener('click', async (event) => {
event.stopPropagation();
await _updateComposerModelVersion(
entry,
anchor.dataset.composerModelChip,
version,
item,
versionList,
);
});
versionList.appendChild(versionItem);
});
item.addEventListener('mouseenter', () => {
_openComposerModelVersionMenu(item, versionList);
});
item.addEventListener('mouseleave', () => {
_scheduleComposerModelVersionMenuClose();
});
disclosure.addEventListener('click', (event) => {
event.stopPropagation();
event.preventDefault();
_openComposerModelVersionMenu(item, versionList, { focusFirst: true });
});
select.addEventListener('keydown', (event) => {
if (event.key !== 'ArrowRight') return;
event.preventDefault();
_openComposerModelVersionMenu(item, versionList, { focusFirst: true });
});
versionList.addEventListener('mouseenter', _clearComposerModelVersionCloseTimer);
versionList.addEventListener('mouseleave', _scheduleComposerModelVersionMenuClose);
versionList.addEventListener('keydown', (event) => {
if (event.key !== 'ArrowLeft' && event.key !== 'Escape') return;
event.preventDefault();
event.stopPropagation();
_closeComposerModelVersionMenu({ focusOwner: true });
});
}
return item;
}
function _buildComposerModelMenuGroup(group, activeEntryId, anchor) {
const section = document.createElement('div');
section.className = 'composer-model-menu-group';
section.dataset.modelGroup = group.key;
section.setAttribute('role', 'group');
section.setAttribute('aria-label', t(group.labelKey));
const header = document.createElement('div');
header.className = 'composer-model-menu-group-header';
const label = document.createElement('span');
label.className = 'composer-model-menu-group-label';
label.textContent = t(group.labelKey);
label.setAttribute('aria-hidden', 'true');
header.appendChild(label);
section.appendChild(header);
group.entries.forEach((entry) => {
section.appendChild(_buildComposerModelMenuItem(entry, activeEntryId, anchor));
});
return section;
}
async function _toggleComposerModelMenu(anchor) {
if (!anchor || anchor.disabled) return;
if (_composerModelMenu || _composerModelOpening) {
const wasSameAnchor = (_composerModelMenu || _composerModelOpening).anchor === anchor;
_closeComposerModelMenu();
if (wasSameAnchor) return;
}
_closeOtherComposerPopovers('model');
const opening = { anchor };
_composerModelOpening = opening;
await _refreshComposerModelEntries();
if (_composerModelOpening !== opening) return;
await _refreshComposerModelOptions(_composerModelEntries);
if (_composerModelOpening !== opening) return;
_composerModelOpening = null;
if (anchor.disabled || !anchor.isConnected) return;
const menu = document.createElement('div');
menu.id = 'composer-model-menu';
menu.className = 'composer-model-menu';
menu.setAttribute('role', 'menu');
menu.setAttribute('aria-label', t('new_chat.model_picker.aria_label'));
if (_composerModelEntries.length) {
const activeEntryId = _composerModelEntries[0]?.entryId || '';
_composerModelMenuGroups(_composerModelEntries).forEach((group) => {
menu.appendChild(_buildComposerModelMenuGroup(group, activeEntryId, anchor));
});
} else {
const empty = document.createElement('div');
empty.className = 'composer-model-menu-empty';
empty.textContent = t('new_chat.model_picker.empty');
menu.appendChild(empty);
}
const separator = document.createElement('div');
separator.className = 'composer-model-menu-separator';
menu.appendChild(separator);
const configure = document.createElement('button');
configure.type = 'button';
configure.className = 'composer-model-menu-configure';
configure.setAttribute('role', 'menuitem');
configure.innerHTML = `
${typeof window.uiIconHtml === 'function' ? window.uiIconHtml('settings', 'composer-model-menu-configure-icon') : ''}
<span>${escapeHtml(t('new_chat.model_picker.configure'))}</span>
`;
configure.addEventListener('click', _openComposerModelSettings);
menu.appendChild(configure);
menu.style.visibility = 'hidden';
document.body.appendChild(menu);
_positionComposerModelMenu(menu, anchor);
menu.style.visibility = '';
anchor.classList.add('is-open');
anchor.setAttribute('aria-expanded', 'true');
const onOutside = (event) => {
const versionMenu = _composerModelMenu?.versionMenu;
if (!menu.contains(event.target)
&& !versionMenu?.contains(event.target)
&& !anchor.contains(event.target)) {
_closeComposerModelMenu();
}
};
const onKeydown = (event) => {
if (event.key === 'Escape') {
event.preventDefault();
_closeComposerModelMenu();
anchor.focus();
}
};
const onViewportChange = (event) => {
const versionMenu = _composerModelMenu?.versionMenu;
const eventNode = event?.target && event.target.nodeType ? event.target : null;
const insideParent = !!eventNode && menu.contains(eventNode);
const insideVersionMenu = !!eventNode && !!versionMenu?.contains(eventNode);
if (insideParent || insideVersionMenu) {
if (event.type === 'scroll' && insideParent) {
_closeComposerModelVersionMenu();
}
return;
}
_positionComposerModelMenu(menu, anchor);
if (versionMenu && _composerModelMenu?.versionOwner) {
_positionComposerModelVersionMenu(versionMenu, _composerModelMenu.versionOwner);
}
};
_composerModelMenu = {
element: menu,
anchor,
onOutside,
onKeydown,
onViewportChange,
versionMenu: null,
versionOwner: null,
versionCloseTimer: null,
};
setTimeout(() => {
if (_composerModelMenu?.element === menu) document.addEventListener('mousedown', onOutside);
}, 0);
document.addEventListener('keydown', onKeydown);
window.addEventListener('resize', onViewportChange);
window.addEventListener('scroll', onViewportChange, true);
(menu.querySelector('.composer-model-menu-item.is-active .composer-model-menu-select')
|| menu.querySelector('button'))?.focus();
}
document.addEventListener('DOMContentLoaded', () => {
_mountComposerModelChips();
window.addEventListener('orkas:boot-ready', () => {
_mountComposerModelChips();
_refreshComposerModelEntries().catch(() => {});
});
window.addEventListener('orkas:model-entries-changed', (event) => {
const entries = event && event.detail && event.detail.entries;
if (Array.isArray(entries)) {
_composerModelEntriesEpoch += 1;
_composerModelEntries = entries.filter((entry) => entry && entry.profileType !== 'managed');
_renderComposerModelChips();
} else {
_refreshComposerModelEntries().catch(() => {});
}
});
try {
if (window.orkas && typeof window.orkas.onPushEvent === 'function') {
window.orkas.onPushEvent('client-config:changed', (payload) => {
const keys = Array.isArray(payload && payload.keys) ? payload.keys : [];
if (!keys.includes('model_catalog')) return;
_closeComposerModelMenu();
_refreshComposerModelEntries().catch(() => {});
});
}
} catch (_) {}
window.addEventListener('i18n-change', () => {
_renderComposerModelChips();
_closeComposerModelMenu();
});
_refreshComposerModelEntries().catch(() => {});
});