Skip to content

1.10.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 8436252: With several chats on one conversation manager, a chat’s first message now starts a conversation of its own, even when another chat has one open or is creating one.

    Do you have to touch your code? Only if several chats share one manager and you create a conversation with manager.createNew() for one of them: give it to that chat (conversationId, or setConversationId()). With several chats on one manager, a chat whose first message was sent while another chat had a conversation open saved that message into the other chat’s conversation, marked the other chat’s row in the list as answering, and told the client the turn belonged to it. Two chats sending their first message at the same moment could end up in one conversation. Each chat now reads only its own conversation: the one it opened, or the one its first message is creating, which the controller exposes as pendingId until activeId holds it.

    The manager still has one activeId, and it still names the conversation the last chat to move opened. It does not drive a chat: calling manager.select() or manager.createNew() yourself changes no chat’s transcript. A chat alone on its manager still saves its first message into the empty conversation you created with manager.createNew(); with several chats, give that conversation to the chat it is for. To open a conversation in a chat, dispatch aparte-conversation-select with that chat’s id as targetId, set its conversationId, or call setConversationId() on it. @aparte/core

  • 5f96251: A plugin’s element can now be used from React as a typed component: createAparteElement(approvalModeElement) from @aparte/react. Each plugin exports a spec for its element (approvalModeElement, modelSelectorElement, triggersElement, diffElement, subagentViewElement, askUserElement, and artifactPanelElement from @aparte/plugin-artifacts/panel), and Vue and Svelte type the tag from it with AparteVueElement<typeof spec> and AparteSvelteElement<typeof spec>.

    tsx
    const ApprovalMode = createAparteElement(approvalModeElement);
    <ApprovalMode
      labels={{ ask: "Ask first" }}
      onApprovalModeChange={(detail) => save(detail.mode)}
    />;

    The spec is core’s new AparteElementSpec type — the tag, its attributes, the members it has only as a property, its events with the name each binds under, and what it reads at connect — with phantom generics, so the attribute, property and event types travel with the value (AparteSpecAttributes, AparteSpecProperties, AparteSpecEvents read them back). It is data and defines nothing. A plugin generates its specs from its manifest; a third party writes one literal and every wrapper binds it the same way, since a plugin can depend on core but never on a wrapper. In Angular, a plugin’s element takes CUSTOM_ELEMENTS_SCHEMA, as any custom element does.

    Deprecated: @aparte/plugin-model-selector/react, /vue, /svelte and /angular. They keep working until the next major; use modelSelectorElement the same way as any other plugin’s spec. @aparte/core, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-diff, @aparte/plugin-model-selector, @aparte/plugin-subagents, @aparte/plugin-triggers, @aparte/react, @aparte/svelte, @aparte/vue

  • b4ff550: Events sent from inside a chat now carry targetId, the id of that chat — aparte-card-action, aparte-card-change, aparte-approval-mode-change, aparte-diff-comment and the others — so a page with several chats can tell them apart. New: chatIdOf(el) and dispatchChatEvent(el, type, detail).

    What carries it now: a message’s aparte-action, aparte-feedback, aparte-feedback-reason, aparte-message-info, aparte-branch-navigate, aparte-link-click and aparte-attachment-preview; the composer’s aparte-composer-change, aparte-action-click and aparte-attachment-preview; the viewport’s aparte-path-changed and aparte-segment-update; aparte-suggestion; aparte-model-change; aparte-approval-mode-change; aparte-trigger-select; aparte-card-action and aparte-card-change; aparte-diff-comment; aparte-artifact-open and aparte-artifact-version-change. Their detail types gain targetId?: string; nothing is removed. A chat with no id names none, and the detail then has no targetId key.

    chatIdOf(el) is the rule core uses everywhere it needs an element’s chat, exported: the target of the nearest aparté element that names one, else the id of the nearest <aparte-chat> or [data-aparte-chat] root that has one, across a shadow root. It replaces the copies the composer, the client, the bubble, the context gauge, the suggestions and the triggers each kept. dispatchChatEvent(el, type, detail, { cancelable }) dispatches a bubbling, composed event with that targetId stamped on the detail (one the detail already has is kept) and returns what dispatchEvent returns: a plugin’s element, or yours, sends its events the way core’s do.

    The plugins that use them need @aparte/core 1.10.0. @aparte/core, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-cards, @aparte/plugin-diff, @aparte/plugin-model-selector, @aparte/plugin-triggers

  • 100a185: An approval question can now show what the call would do: a tool’s display takes approvalPreview, and the panel mounts what it returns between the question and the buttons.

    approvalPreview(call) returns an element, a string of HTML (sanitised) or null; requestUserInput() takes the same thing as preview on an approval request. setupDiff() registers a diff preview for an edit tool from its input (before and after, or old_string and new_string), and takes a preview option for another shape, or false for none. @aparte/core, @aparte/plugin-diff

  • 7476930: A new config given to <AparteChat> is now applied; it was read once, when the chat mounted, and a later one was ignored without a word.

    Pass a config that keeps its identity across renders (created once, or memoized): each new object is applied as a new config, and every element inside re-resolves it. The same config handed again changes nothing.

    When the prop changes, every element inside moves to the new config, and the chat’s two locale strings (the loading line, the waiting line) follow the new language. The messages on screen stay. If the new config registers another conversation manager, the open conversation is opened again from it when it holds that conversation; when it does not, or the new config has no manager, the chat keeps saving that conversation to the manager it had, and the next conversation it opens comes from the new config. A config given while a reply is streaming waits for that turn to end, so a reply is never half-drawn with one configuration’s renderers and finished with another’s; the last one given wins.

    The wrappers call the new AparteChatHost.setConfig(config), which does the same for a binding of your own. @aparte/core, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

  • f65be56: <aparte-conversation-list> takes group: { key, label } on an item to list it under a heading of your own, and a renderMeta(item) property to draw a mark of yours after a row’s title.

    Nothing to change in your code. A row with a group is listed there instead of under its date or Pinned; the groups come first, in order of first appearance, and the rows without one keep the date groups below them. renderMeta returns an element, a string (text, never markup) or null; it sits beside the title button, not inside it, so a button of yours in it keeps its own name and tab stop. Setting it draws the rows again. @aparte/core

  • e5d60b4: After a failed turn, every later request now sends the same history: the failed message goes with the next one from the next request on, or is left out of every request when its error says the same request fails again.

    Do you have to touch your code? No. A server that compared histories and took a message ending in "\n\n" + <a recorded message> for that message can drop that workaround: the history no longer changes from one request to the next.

    • What changed. The send cut the history at the last answered reply, so the request after a failed turn left the failed message out, and the request after that put it back, joined to the next message. A server that keeps its own record saw the past change under it. The send now cuts only the message being sent, and one rule, decided by the code on the failed reply’s error segment, says what a failed turn leaves:
      • the network, a 5xx, a rate limit, a key, a Stop before the first token: the message is kept, and goes joined to the next one (mergeAdjacentUserMessages), as retry and edit already sent it;
      • USAGE_CONTEXT_EXCEEDED, PROVIDER_POLICY, USAGE_BAD_REQUEST: the message, and every message that went out with it, is left out of every later request, or the conversation could not go on;
      • a message that carried files is left out too: the history sends a message’s text, never the files a send read, and the model would be asked about a file it is not shown.
    • Who follows it. Send, retry, edit, the resume of a paused turn, the context gauge (estimateWireTokens, measureContext) and @aparte/plugin-compaction, whose cut no longer weighs a message no request sends and whose summary no longer reads it.
    • New export. withoutAbandonedTurns(messages) returns the messages a later request still sends, for a history function or a server of your own.
    • What it fixes downstream. An AG-UI thread numbers its messages by place, and the ids no longer name two different messages in one thread. n8n, which receives only the last message, now hears the failed one with the next instead of never. @aparte/core, @aparte/plugin-compaction
  • ff401d3: A pause on a sub-agent’s call now survives a reload: resumeDeferred asks it again under the sub-agent’s name, and the run resumes with the answer.

    Do you have to touch your code? No. A storage adapter that saves the message as it is keeps the new field; one that copies chosen fields should copy deferredCalls too.

    • What was wrong. An agent elsewhere (an AG-UI agent, a server loop of your own) can pause on a call its sub-agent made. That call has no row in the reply, so nothing the conversation saved said a call was waiting: after a reload, resumeDeferred found no pause, the question was never asked again, and the agent kept waiting for an answer.
    • What the reply keeps. AparteMessage.deferredCalls, a list of AparteDeferredCall — { toolCallId, name, input, reason, agentId, agentName, ticket } — written when the run pauses, before aparte-message-paused, so the conversation saved then has it. It names nothing of a plugin: the call, why it waits, the sub-agent’s id and the name it was announced with, the server’s ticket. It is removed once the pause is answered, and closed by a Stop or a new message, like a row’s deferred.
    • On a reload. resumeDeferred resumes the reply’s own paused calls and these together, each sub-agent call with its agentId, asked under its sub-agent’s name (Allow read_file for Researcher?), and an approvalResolver receives call.agent. The call that opened the sub-agent stays open across the load, so the resume hands it back to the agent unanswered rather than “stopped”. @aparte/core
  • 8f8be35: Add --aparte-warning-surface and --aparte-info-surface, and the chevronDownIcon, chevronUpIcon and panelLeftIcon glyphs in @aparte/core/icons.

    The two surfaces complete the intent family: success and error had one, warning and info did not, so a rule reading them got an invalid value and painted nothing. They use the same recipe. The chevrons name by direction what expand and collapse name by state; panelLeft is the usual glyph for a desktop sidebar toggle. @aparte/core

  • d2f054c: approvalResolver, an approval policy and requestInterceptor now receive the turn they are called for, { conversationId, messageId, targetId } (AparteTurnContext), and so do the server handler’s approvalPolicy and prepareRequest.

    ts
    new AparteClient({
      approvalResolver: (call, signal, { conversationId }) =>
        cards.ask(conversationId, call, signal),
    });

    Do you have to touch your code? No. Each is an extra argument a callback is free to ignore. A resolver that read the open conversation from the app’s own state, or from a capturing listener on aparte-conversation-loaded, can read it from the turn instead.

    • Why. The client asks again about a paused call the moment a conversation is loaded (resumeDeferred), before a framework has rendered the new id: a resolver that read the app’s state filed the request under the conversation shown before, and its card never appeared. The turn is read when the person acted, at every call site: a turn in the page, a paused server run, a resume after a reload.
    • Where it goes. The third argument of approvalResolver(call, signal, turn) and of an approval policy (call, tool, turn) (absent only when config.ruleOnToolCall(call) is called by hand, which now takes the turn as an optional second argument); the second of requestInterceptor(request, turn); on the server, approvalPolicy(call, tool, turn) and prepareRequest(request, req, turn), with { messageId, conversationId } as the page sent them. The sub-agent whose call it is stays on call.agent.
    • On the event and the panel. aparte-tool-approval-request carries messageId and conversationId, and the approval core puts to the panel carries them on the request (AparteElicitationRequest.conversationId, messageId), for a presenter of your own. @aparte/plugin-ask-user and the n8n buttons tool put the conversation on the question they ask.
    • The approval preview. The request also carries preview, what the tool display’s approvalPreview draws for the call.
    • A browser tool that answers a paused server run is now told its conversation (context.conversationId), like a tool the page’s own loop runs.
    • AparteToolApprovalResolver is now its own type, engine’s resolver plus the turn. Passing one straight to runStreamAgent needs a wrapper: (call, signal) => resolver(call, signal, turn). @aparte/core, @aparte/engine, @aparte/runner-n8n, @aparte/plugin-ask-user
  • c4e34a9: Giving a chat back the conversation it just created (conversationId set from onConversationCreated, or bound to the conversation manager’s activeId) no longer reloads it in the middle of the first reply. New: getConversationId() on every <AparteChat> says which conversation that chat shows.

    Do you have to touch your code? Only if a class of yours implements AparteChatImperativeApi: add getConversationId(). Otherwise nothing changes; the pattern the conversation persistence guide documents now works as written:

    tsx
    const [conversationId, setConversationId] = useState<string | null>(null);
    <AparteChat
      conversationId={conversationId}
      onConversationCreated={setConversationId}
    />;

    Before, the id came back while the first reply was streaming and the chat took it as a new conversation to open: it re-read the conversation from the manager, which did not hold the reply yet, so the reply’s text landed in the person’s bubble, the person’s message disappeared and Send stayed disabled. Bound to the manager’s activeId (natural in Vue, Svelte and Angular), the id came back even earlier, before the chat itself held it. A conversationId prop is now a no-op for the conversation the chat already shows or is creating. The imperative setConversationId(id) is unchanged: the same id again still re-reads the conversation.

    getConversationId() is on AparteChatImperativeApi, so it is on React’s ref handle, Vue’s and Svelte’s component instance, Angular’s component, and useAparteChat() / createAparteChat(). It returns the conversation the chat opened, or the one its first message is creating, and null before either. Unlike the manager’s single activeId, which names whichever chat opened a conversation last, it is per chat. AparteChatHost gains the two methods the wrappers call: syncConversationId(id) and getConversationId().

    In Angular, setConversationId() called on the component no longer leaves the [conversationId] input’s next value compared against a stale id. @aparte/core, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

  • 60b91c1: A question or approval whose options are buttons now answers to the keyboard: 1 to 9 press the matching option, and Escape means Skip (question) or the one refusing option (approval).

    Each option wears its number and carries aria-keyshortcuts. The digits work only while an option has the focus, so a number typed in a sentence stays text; a held key, a modifier, an IME composition and a text field (the “Other” field, the instruction) are ignored. Escape on an approval presses the option with tone: 'deny' only when there is exactly one, and it no longer closes a launcher the chat sits in while a panel is asking. On by default. @aparte/core

  • aa20dd2: Add .aparte-segmented: a pill-shaped row of choices over native radio buttons, with --sm and --block, and keyboard focus drawn on the chosen segment.

    Wrap each <input type="radio"> and its text in a <label class="aparte-segmented__item"> inside a <div class="aparte-segmented" role="radiogroup">. A row of buttons that each do something wears the same look, with aria-pressed on a .aparte-segmented__item button. The cards’ range buttons now use this recipe. Their markup keeps aria-pressed, data-card-key and the class names aparte-rich-card__segmented and aparte-rich-card__segment, so a stylesheet of yours that reached them still does; the look itself now comes from .aparte-segmented. @aparte/core, @aparte/plugin-cards

  • 1306924: <aparte-sidebar collapsed="rail"> folds the column to a 56px rail that stays usable, and .aparte-tooltip-anchor--hover shows a tooltip on hover and focus with no script.

    Nothing to change in your code: a plain collapsed still folds to nothing, and an anchor without the modifier behaves as before. In a rail the children you mark data-rail stay, the others and any .aparte-sidebar__label or .aparte-sidebar__brand inside a marked one hide, and the sidebar takes no inert. The width is --aparte-sidebar-rail-width; the tooltip’s delay is --aparte-tooltip-delay (400ms). The rail has no keyboard shortcut and the element does not choose when to be one: your toggle sets the attribute. @aparte/core

  • 73253c3: A tool’s display can now set the row’s note and activity (text, or a function of the call), and registerToolLineProvider() adds a tool-line provider without replacing the one the app set.

    The app’s display wins over a provider, field by field. Providers are asked in order, setToolLineProvider() first, and the first one that answers a call wins; registerToolLineProvider() returns the function that removes it, and getToolLineProviders() lists them. setToolLineProvider() is unchanged. @aparte/plugin-subagents registers its provider instead of setting it, so it no longer overwrites the app’s. @aparte/core, @aparte/plugin-subagents

  • aa20dd2: What setupWeatherCard() and every other card setup returns now also has .refresh(), which runs actions(data, { origin }) again for the cards on screen.

    Nothing to change in your code: the return is still the function that takes the card off. Use refresh() when what actions reads changes after the card is drawn (the person signs in, an item is saved); the buttons are redrawn in place, with the focus kept, and a card that already left the page is left alone. The return type is the new CardSetupHandle. @aparte/plugin-cards

  • ae2b087: useAparteClient in React now calls the function options of the latest render, so a resolver that reads state sees the state of now; calling a conversation helper’s init() a second time no longer leaves the first manager writing its lists.

    Nothing to change in your code; the ref you may have added to work around it keeps working.

    • React: the client is still built once, on the first render, but keyResolver, approvalResolver, requestInterceptor, history (as a function), targetResolver and fileInjectFilter are called through the latest render’s options. streamRunner is not: it is read once and handed to the client as it is, because the client recognises the engine’s own loop (runStreamAgent) by identity; a runner that reads state reads it through a ref. An approvalResolver over the conversation’s mode, or a keyResolver over a settings form, no longer sees the values it had at mount. The other options (config, scopeToTargetId, maxTurns…), and whether a function option is there at all, are still read once: remount with a key to change them. Vue, Svelte and Angular closures already read live values (refs, stores, signals), and their pages now say so.
    • init() of React’s useConversationManager, Vue’s useConversationManager, Svelte 4’s createConversationManager and Angular’s ConversationManagerService, called again, replaces the manager and stops following the one before; its subscription used to stay, and the first manager’s notifications went on overwriting conversations and activeId. (Svelte 5’s createConversations() already did this.) Its options are read when it runs: a titleProvider that reads state reads it through a ref, or is replaced with manager.setTitleProvider(). @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue
  • @aparte/runner-n8n sends n8n the message just typed, also after a failed turn; it sent the failed message again, joined to the new one, which n8n’s memory may already hold. The run now names the person’s message it answers: userMessage, { content, messageId? }, on StreamRunOptions, which AparteClient fills on a send, a retry and an edit.

    Do you have to touch your code? No. A runner whose agent keeps its own memory and is sent only the new message reads opts.userMessage rather than the last user message of baseRequest.messages, which after a failed turn is that message joined to the one before it. With a client that does not name it, @aparte/runner-n8n reads the history as before. A first message whose turn failed now keeps its n8n session for the next one. @aparte/core, @aparte/engine, @aparte/runner-n8n

Patch Changes

  • 81d38ee: An element handed a value it already holds no longer closes, unfocuses or resets what the person was doing in it — re-rendering a framework wrapper with the same props is now harmless.

    • <aparte-triggers>: re-setting triggers keeps the open list open, on the row the keyboard was on, when the trigger it shows is still declared at the same place; a child list opened from a row stays open, on its own row, while that row is still listed, and closes with it otherwise. The commands-and-mentions recipe re-set it on every React render, so the list opened on @ and closed at once.
    • <aparte-approval-mode>: re-setting labels renames the options in place, so an open list stays open.
    • <aparte-diff>: re-setting diff with the change it shows — the same text or object, or an equal one, such as an inline { path, before, after } — keeps the lines picked, the comment field and its text, the folds and the focus. The same object mutated into another change is drawn and coloured from its new text, and keeps the folds and the lines picked that still exist in it.
    • <aparte-artifact-panel>: re-setting render with the same function keeps the tab and the preview the reader chose.
    • <aparte-conversation-list>: re-setting conversations while a row’s menu is open or a title is being renamed waits for them to end, instead of closing the menu and dropping what was typed.
    • <aparte-suggestions>: re-setting suggestions keeps the focused chip and the row’s scroll.
    • An attribute written again with the value it has does nothing, on every element of core and the plugins (eleven of them redrew or rewrote their parts).

    applyElementProps, which every AparteUi and the generated React components use, now writes an attribute or a CSS variable only when it differs from the value it last wrote on that element; an object or a function is still assigned every time, because it may have been mutated in place (a Vue push behind a deep watch, a Svelte 5 proxy, Svelte 4’s arr = arr). An element that changes its own attribute keeps what it did until the prop next changes, as the React components already behaved.

    A test reads every element of core and of the seven plugins with a manifest and holds each to this: an attribute written again makes no mutation under the element, and a property assigned again keeps the focus and what is open, selected or typed. @aparte/core, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-diff, @aparte/plugin-model-selector, @aparte/plugin-triggers

  • 1306924: A select’s trigger text is now the value it shows and nothing else, so textContent of the trigger reads “gpt-4o” and not every option’s label run together.

    Nothing to change in your code, unless a test read the hidden width labels (.aparte-select-label-sizer > span) as text: they now carry the label in data-label and CSS draws it as generated content. The trigger keeps the width of its widest option, as before. The testing guide lists the select’s hook. @aparte/core

  • 9696160: aparte-subagent-open now names its chat in targetId under a framework wrapper too, not only inside <aparte-chat>.

    The line looked for the <aparte-chat> tag, and the React, Vue and Svelte wrappers render a [data-aparte-chat] root instead, so on those three the event came without the chat’s id. It now finds its chat the way every chat-scoped event does (chatIdOf). A line in a standalone <aparte-subagent-view> still names the chat that view reads (for, or chat), wherever the view is mounted. @aparte/plugin-subagents

Version-only bumps (no changes of their own): @aparte/runner-ag-ui, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-chartjs, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-titler, @aparte/locales, @aparte/docs-mcp.

1.10.1

Every @aparte/* package ships at this version (they are released in lockstep).

Patch Changes

  • 08b0986: AparteConversationSelectDetail.id is now string | null: null means a new conversation. Handle it where you read the event’s id as a string.

    aparte-conversation-select with { id: null } is the documented way for a New chat button to start a new conversation, and every chat bound to a manager honours it, but the type said id: string: dispatching it took a cast, and a typed listener’s “new conversation” branch read as dead code. The list itself still sends a row’s id. A listener that passes id on to setConversationId() or a conversationId prop needs nothing, since both take string | null; one that uses it as a string (an index, a lookup key) now gets a type error where null was always possible at runtime. @aparte/core

  • 3e390fc: onApprovalModeChange (and any listener typed from approvalModeElement) now receives ApprovalModeChangeDetail, whose mode and previousMode are ApprovalMode; drop the guard or cast you used to index a Record<ApprovalMode, …>.

    The switch and the /approval command only ever send one of the four modes, but the element’s spec typed the detail as core’s AparteApprovalModeChangeEventDetail, where both are string, so createAparteElement(approvalModeElement) called back with a string. ApprovalModeChangeDetail is new, exported from the plugin, and extends core’s type, so a listener on the DOM event map keeps compiling. Core’s type stays string, for a host that registers modes of its own. @aparte/plugin-approval

  • b4bdc29: <AparteChat conversationId={id}> now draws that conversation when it mounts, also when the conversation manager already holds it loaded; a setConversationId(id) after mount is no longer needed.

    Nothing to change in your code; remove the workaround if you added one. A conversation the manager holds (one another chat had open, on the same manager) is drawn at once, during the chat’s mount. The messages prop’s effect then ran for the first time, took the initial [] for a list pushed by the parent, and replaced the transcript with it: the chat showed its empty state while getConversationId() returned the id. The effect’s first run is now recognised as the value the chat was created with. A conversation that has to be fetched (loadFull) was not affected, nor were Vue, Svelte or Angular, whose messages watchers do not run on mount; each wrapper now has a test for this case. @aparte/react

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.11.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • c1912b3: A registered message action can show its label as text and stand before the built-in buttons: registerAction({ …, display: 'label', position: 'start' }). Existing actions are unchanged.

    display is 'icon' (the default, as before), 'label' or 'both'. icon is optional with 'label', and a button left with no icon to draw shows its label rather than an empty box. A button that shows its label is named by it, with no tooltip repeating it. position is 'end' (the default, as before) or 'start'; order sorts the actions on each side.

    label is now read as a key of the locale when the locale has it, as its documentation already said and the bubble did not do: add yours with extendLocale, and the words follow the chat’s language. A label the locale does not have is shown as written. @aparte/core

  • 289cf4d: A request whose history starts at a checkpoint names the summary it opens with in _meta.historySummary, so a server that keeps its own history can tell it from what the person said. Nothing to change in your code.

    The summary still goes as a user message under its preamble, joined to the person’s next message when one follows. historySummary is the text that message opens with, exactly; what follows it, after a blank line, is the person’s. It travels in _meta rather than on the message, so a backend that hands messages to a model API as they are never meets a field it does not know. @aparte/core

Patch Changes

  • 77f1d8e: A diff line’s two numbers are set further apart, so a line far down a file (118 118) no longer reads as one number. Nothing to change in your code.

    Each number now keeps --aparte-space-5 on both sides instead of --aparte-space-2: 20px between the old number and the new one with the default spacing, where it was 8px, about one character once a number filled the column’s three-digit minimum. 20px is what a unified diff leaves between them (GitHub and GitLab). The gutter’s selectors are documented under Customize, for an app that wants a rule between the two columns. @aparte/plugin-diff

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.12.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 3ba3797: A checkpoint can cover the message that carries it: contextSummary: { …, includesSelf: true } starts the history after that message, so a summary of everything so far no longer leaves the last answer counted (#246).

    A checkpoint reads “from this message on, the summary stands for everything before”, so its own message was always read and sent. A host that summarised everything, the last answer included because keeping it would free nothing, had only that answer to put the checkpoint on: the gauge read about full right after a compaction that had freed most of the window, and the next request carried the answer again. With includesSelf the history, the gauge and the request start after it, and the separator is drawn under the message rather than above it. It never covers the question being answered: on a last user message it reads as an ordinary checkpoint. Retention that hands the checkpoint down to a later message drops the flag, since the inheritor is kept. @aparte/core

  • 9930f0b: A send can be held: call preventDefault() on the new aparte-before-send event (onBeforeSend / @before-send / onbeforeSend in the wrappers) and the message stays in the composer, text and files, with nothing added to the thread; getComposer()?.submit() sends it later (#245).

    The event goes out before aparte-send, with the same detail. aparte-send itself could not be the cancelable one: the conversation controller appends the person’s message in the capture phase on the chat, so it runs before any listener an app can add, and a cancel there arrived after the message was already in the thread. A first event of its own has no such race, the shape the platform uses for beforeinput before input. The getComposer() documentation now names setValue(), submit() and addAttachments(). @aparte/core

  • 844c6c5: A chat whose turns run on a server can list the server’s models: registerAIProvider(createModelCatalogue({ id, name, models })) registers a provider that lists them and runs none, and <aparte-model-selector> shows them (#244). aparte-model-change now says picked, so an app that asks before switching can tell the person’s pick from its own revert.

    createModelCatalogue is the provider a server-loop page used to write by hand, a chat() that rejects: the selector lists its models, the one selected goes out on every request, and its capabilities gate what it cannot do. A page with no stream runner that sends anyway gets a PROVIDER_MISCONFIGURED error that says so. picked is true when the person chose in the list, false for setSelection() and for auto-select; without persist, a cancelled switch puts the old model back with setSelection() and that change no longer reads as a pick. @aparte/core, @aparte/plugin-model-selector

  • 6c9b0af: A question can be answered from outside its chat: aparteGlobalConfig.observeElicitations(listener) hands the app each question and approval a chat puts on screen, with respond() to answer it and settled to know when it no longer waits (#250).

    The chat still asks: its panel is up and the person can answer there. Whichever answers first is the answer, and an answer from outside takes the chat’s panel down. request.conversationId names the conversation that asked, so an inbox of everything waiting across conversations can answer an ask_user question the way approvalResolver already let it answer an approval. The answer is what the panel would have resolved, { action: 'accept', content } with the value the question’s schema collects (for ask_user, the option’s value, a string[] for several, free text, or { q1, q2 } for several questions), or { action: 'decline' }. AparteElicitationPending is the type. A listener that throws is reported at the console and the question is still asked. The elicitation guide has it under “Answer from outside the chat”. @aparte/core

  • 7d17240: A message written while a reply streams can wait for it: aparteGlobalConfig.setQueueWhileStreaming(true) makes Enter queue the draft above the field, and each queued message is sent when the reply ends (#248). Off by default.

    Each queued message shows with a button to take it back into the field and one to remove it. When the reply ends well (aparte-message-done) the first one goes out through the same aparte-before-send and aparte-send as a message sent by hand, so a held send holds it too, and the next one waits for the reply to it. After a Stop or an error nothing is sent: what was queued comes back into the field. The Stop button stays Stop. composer.queue() queues from a button of your own, and the composer’s state carries queued (AparteQueuedMessage[]). Three locale keys, queueLabel, queueEdit and queueRemove, in the nine languages.

    The norm it follows: Cursor queues follow-ups typed during a run and sends them in order once it ends, each removable; Codex queues them with Tab, and with Enter in its IDE extension. @aparte/core, @aparte/locales

  • 39979a6: A chat can say what its Stop button interrupts: stop-label on <aparte-composer>, or its stopLabel property, names the button “Stop the sub-agents” in place of the locale’s stopButton (#249). Set it back to null when the run it named is over.

    It is the accessible name and the tooltip of the composer’s send button while it is Stop, and of <aparte-composer-cancel>, on this chat only. The one way before was extendLocale({ stopButton }), which renamed the Stop of every chat sharing the config, a locale edit standing in for state. An attribute, like the composer’s other options, so a framework binding ([stopLabel] in Angular, a prop on the generated components) reaches it the way a script does. The sub-agents guide shows it following the sub-agents that run. @aparte/core

  • ff23780: A fold of sub-agents can say where they stand: setTurnSummary({ label: subagentsTurnLabel }) writes the fold’s line as “3 sub-agents · 1 done, 2 running” (#247). label takes any function of yours too.

    setTurnSummary takes a label function, called with the fold’s steps, running and the chat’s config each time they change; a string replaces core’s line (“Working”, “Worked 9 s · 7 tools”) and the running step’s name, null keeps them. A line of the app’s is a polite live region; one that throws leaves core’s line. @aparte/plugin-subagents exports subagentsTurnLabel, which counts the fold’s sub-agents by state in the chat’s language, with six locale keys (subagentsCount, subagentsDone, subagentsRunning, subagentsWaiting, subagentsFailed, subagentsStopped) in the ten languages, and leaves core’s line under two sub-agents.

    The headline goes on the fold core already draws, moves and keeps up to date, not on a second grouping of rows: with openWhileRunning the lines show under it while the sub-agents work. A sub-agent that waits for the person or failed stands out of the fold, where it has to be read. @aparte/core, @aparte/plugin-subagents

Patch Changes

  • 3795730: A change of the config no longer closes a conversation list’s open row menu or a title being renamed, and the list redraws only when its words or its glyphs change. No code to change (#251).

    <aparte-conversation-list> redrew itself on every aparte-config-change, which goes out for every change of the config (a provider registered, a model selected, a tool display), and it did so unheld: a menu open under the pointer was detached, and a rename lost what was typed, when an app registered its models a second after launch or again when a model loaded. It now redraws for a new locale or a new icon set only, and waits, as conversations already does, for an open menu, a rename or a press to end. @aparte/core

  • f0b2b37: A plan card sent again folds the earlier card of the same plan to its header, and a plan’s “in progress” ring stops turning once the reply is over. No code to change.

    An agent that calls its plan tool at each step drew a card per call, and the earlier ones stayed whole: their step “in progress” kept turning above the card that said the plan was done. In a chat, the latest card of a plan (cards of one plan share its title) is now the plan; an earlier one keeps its title, its “2 of 4 done” and its bar, what it said then, and gives up its steps and its motion (data-plan-superseded). Codex and Claude Code keep the earlier versions of a plan in the transcript too, still. A reload or a redraw lands on the same answer, read from the page in the conversation’s order. @aparte/plugin-cards

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/docs-mcp.

1.12.1

Every @aparte/* package ships at this version (they are released in lockstep).

Patch Changes

  • 1da0eee: <aparte-diff> no longer draws its rows again when handed the same comments or the same change; nothing to change in your code.

    A framework hands comments and diff on every render, often as a new array of the same comments (review.filter((c) => c.path === file)) or a new { path, before, after } with the same texts. Each drew every row again: what the reader was doing was carried over, but every row was a new element, so a text selection in the code was lost and the field being written in left the page and came back. A list of the same comments, or a change with the same texts, now draws nothing. A comment changed in place and handed back is still drawn, and an app’s own fields on a comment (id, say) do not count, since the view does not show them (#253). @aparte/plugin-diff

Version-only bumps (no changes of their own): @aparte/core, @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.12.2

Every @aparte/* package ships at this version (they are released in lockstep).

Patch Changes

  • d47c000: A model chosen through /model now sends aparte-model-change with picked: true, as a pick in the list does; nothing to change in your code.

    The rows of /model in the triggers menu ran setSelection(), so the person’s choice was told with picked: false, like a change made by code. An app that asks before switching (if (!picked) return) let it through without asking. Choosing through /model the model already selected now changes nothing and sends nothing, as in the list. setSelection() still sends picked: false (#255). @aparte/core, @aparte/plugin-model-selector

  • c2d03df: A RUN_ERROR whose code is one of aparté’s error codes (USAGE_RATE_LIMIT, CONFIG_INVALID_KEY…) now keeps that code, so the error card says its sentence; nothing to change in your code.

    Every RUN_ERROR used to become a PROVIDER_ERROR, so the card read “The assistant couldn’t answer. Try again in a moment.” whatever the agent said. An agent that finds a reason mid-run (a tool hitting a rate limit) has already answered 200, so no HTTP status can carry it: the code is the only place left. aparté’s own agent wire already read a run-error line’s code this way; the AG-UI runner now does the same. Any other code, or none, is still a provider error, the agent’s own value kept in the error’s data. @aparte/runner-ag-ui

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.13.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 205d5a9: A message can now say who wrote it (author), a notice can mark what happened in the conversation (kind: 'notice'), a note can sit under a message (note), and setAutoReply(false) keeps the AI quiet while a person answers.

    Nothing to change in your code, with one thing to know first: a conversation saved with notices, opened with an older version of aparté, shows each notice as a reply of the AI.

    • AparteMessage.author (AparteAuthor: name, type 'ai' | 'human', avatar, id) names the writer; role still says the side. The bubble shows the name and the picture, carries data-author-type and data-author-name, and a person’s message offers no regenerate, rating or model details. An avatar provider is told the author (render(role, host, { author })), and registerAction takes bubble.authorTypes. isModelReply(message) and authorTypeOf(message) are exported.
    • kind: 'notice' draws a line across the transcript (role="note"), never sent to the model and never answered. note is a short line under a message, set with updateMessage(id, { note }).
    • config.setAutoReply(on, conversationId?) / getAutoReply(conversationId?): off, a person’s message is shown, announced and saved, and no turn starts — not from a send, a queued message, a regenerate, an edit or the resume of a paused reply. Regenerate and edit are disabled meanwhile. Per conversation, or for the whole chat; not stored, so apply it again on aparte-conversation-loaded.
    • aparte-send carries messageId, the id of the message on screen. A message appended or updated outside a turn fires aparte-transcript-change, and the conversation controller saves it; manager.addMessage() now writes the stored branch tree too.
    • A message appended while a reply streams no longer cuts into it: the turn writes into its own message by id, and the history is cut at the message that was sent, wherever it sits.
    • What the model reads: an author’s name goes as the message’s name; two messages in a row on the same side are joined into one, assistant ones too unless they call tools (before, only the person’s were), since strict chat templates refuse two in a row; joined messages from different authors open each named author’s words with the name (Marie: …).

    The guide is “Humans in the conversation”. @aparte/core

  • 205d5a9: A message of the agent loop can carry its author’s name (StreamAgentMessage.name), passed through to the provider. @aparte/engine

  • 205d5a9: A message’s author now goes to the agent as the message’s name, on user and assistant messages alike. @aparte/runner-ag-ui

  • 205d5a9: sendNames: true sends a message’s author as OpenAI’s name field; it is on in presets.OPENAI.

    Off by default, because other OpenAI-compatible servers refuse the field (Mistral answers 422). The name is fitted to what the API accepts — letters, digits, _ and -, up to 64 characters — and left out when nothing is left of it. @aparte/provider-openai-compat

Patch Changes

  • f4b255a: A new message no longer flashes 320px tall for a frame before taking its own height.

    Nothing to change in your code. The bubbles skip drawing what is off screen (content-visibility: auto), and one that has never been drawn is laid out at the 320px fallback. A message just appended lands below the fold until the scroll catches up a frame later, so the transcript was pinned to that height and then snapped back: a flash under the person’s message, the reply, or a message the app appended (an advisor’s, a notice). The newest two bubbles are now always drawn (aparte-chat-bubble:nth-last-of-type(-n + 2)); the history above keeps the skipping. @aparte/core

  • 205d5a9: The summary now leaves notices out and names a person’s message by its author (Marie: …), so it never puts an advisor’s words in the AI’s mouth. @aparte/plugin-compaction

  • 205d5a9: /retry now targets the AI’s last answer, never a notice or a person’s message after it.

    When a notice or a person’s message follows that answer, regenerating it would drop what came after, and the chat refuses, as its own Regenerate button does. @aparte/plugin-triggers

  • 205d5a9: A message with an author and a notice now draw right on the first paint: the bubble gets data-kind, name and data-author-type from the message. @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

Version-only bumps (no changes of their own): @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/locales, @aparte/docs-mcp.

1.13.1

Every @aparte/* package ships at this version (they are released in lockstep).

Patch Changes

  • 8a12c10: A long notice now wraps onto several lines instead of being clipped at the edge of the chat.

    A notice (kind: 'notice') wore the divider recipe, whose label is a single word that never wraps. “Marie joined the conversation” fit; a sentence such as “Someone of the team will answer you here, usually within minutes” ran past a narrow chat and was cut. The notice’s text now wraps, centred, and the lines on either side keep a short stretch. @aparte/core

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.14.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 749770c: A / command and a trigger row can show a badge at the end of the row: badge: 'Beta'. It stays while the person filters the list.

    Nothing to change in your code. AparteCommand.badge and AparteTriggerItem.badge take a short text, drawn as the kit’s small badge (.aparte-menu__badge) before a submenu’s chevron, as text. A command’s group heading says a state only while nothing is searched, because a filtered list is ranked rather than grouped; the badge is on the row itself. commands.override changes it like any other field. A row drawn by your own render draws its own badge. @aparte/core, @aparte/plugin-triggers

  • c4fa388: A custom error renderer now receives appCode: the code your own server or agent ended the run with (engine-died), which it could not see before.

    Nothing to change in your code. A run-error line on aparté’s agent wire, or an AG-UI RUN_ERROR, can carry a code aparté does not know. The runner folds it into PROVIDER_ERROR, so the default card still says a provider error in the reader’s language, and keeps the raw value in the error’s data. That value reached the aparte-message-error event only: the card saw PROVIDER_ERROR, and once the reply was saved the app’s code was gone. It now rides on the error segment as appCode, saved with the message, and setErrorRenderer receives it beside code. A code of aparté’s own (USAGE_RATE_LIMIT) is the error’s code as before, and sets no appCode. The default card is unchanged: it shows the sentence of PROVIDER_ERROR, never the server’s words. @aparte/core

  • 2901291: New stop-key on the chat and the composer, stopKey on the framework components: a key that stops the reply being written, as Stop does. stop-key="Escape"; none by default.

    Nothing to change in your code. The key counts while the focus is in the composer, pressed alone, and once nothing inside took it: the / menu, a select, a question or an approval in the composer keep their own keys. In a launcher, the first Escape stops the reply and the next one closes the chat.

    Every element of aparté that takes Escape now cancels the keydown, and the accessibility guide says in which order they answer, so a handler of yours reads event.defaultPrevented. Two did not: the Restore question of a compaction stopped the key without cancelling it, and a stock chart’s cursor did neither, so Escape on a chart in a launcher also closed the card. The chart now takes Escape only while its cursor is shown. @aparte/core, @aparte/plugin-cards, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

Patch Changes

  • 2aa71b8: <aparte-icon> with a name no icon has now says so once in the console, instead of drawing an empty square in silence.

    Nothing to change in your code. name="plus" and name="panel" draw nothing until registered: the glyphs of @aparte/core/icons are SVG strings, not names, and <aparte-icon> knows core’s names and the ones added with registerIcons. The warning names the name and how to register it; it comes once per name, and not for a name registered right after the element mounted. The Icon page now says it, with the registerIcons line. The menu recipe’s own example named chevronRight, which is not one of core’s names, so its chevron drew nothing: it now names nextBranch. @aparte/core

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/locales, @aparte/docs-mcp.

1.15.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 20124fb: An error renderer can return null for an error it does not change: that error keeps aparté’s card, translated on a language switch as before.

    Nothing to change in your code. setErrorRenderer replaced the card for every error, so an app that wanted its own words for one code (appCode === 'engine-died') rebuilt aparté’s card by hand for all the others: a copy of its markup that drifts, and that a language switch no longer rewrote. Returning null made the card vanish. null or nothing now draws aparté’s card for that error, exactly as without a renderer; a card you return is still never rewritten, even one that copies aparté’s classes. AparteErrorRenderer returns string | HTMLElement | null | undefined. @aparte/core

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.15.1

Every @aparte/* package ships at this version (they are released in lockstep).

Patch Changes

  • 0ff08c9: Reasoning that arrives after its block was closed now opens a new block, instead of growing a block that already reads “Thought for 3s”.

    Nothing to change in your code. A reasoning block closes when the answer starts or a tool is called, and only a turn-start let the next reasoning open a block of its own. Later reasoning in the same turn was appended to the closed block, folded, above the calls made since, and the block kept its finished label while it grew. It happened to a server loop that sent one turn-start per run instead of one per model call (apartejs/aparte#272), and as well to a model that reasons again after it starts answering within one call (the engine, ai-sdk and AG-UI all pass that through), in the reply and in a sub-agent’s transcript.

    The server-loop guide now says what a server writing its own wire must send: a turn-start before each model call, a sub-agent’s with its agentId. @aparte/core

  • 350930e: A call in a sub-agent’s conversation under its line now shows its own state: a failed or refused call no longer reads in the success colour, and a reply being written has one caret instead of one per paragraph of the transcript.

    Nothing to change in your code. Five rules of the tool row (the success ink of a call that is done, the quiet line’s target face and chevron place, a queued call’s muted name, a running quiet call’s state word under reduced motion) were keyed on the row’s state with a descendant combinator, so they reached every row drawn under it: with setupSubagents({ details: 'transcript' }) a failed call in the transcript of a line that was done read “Failed” in green (apartejs/aparte#271), and a quiet line made the calls under it quiet. They now name the row’s own line; their specificity is unchanged. The streaming caret (setStreamingCaret) had the same reach and blinked after the last paragraph of every text in a transcript; it now stays at the reply’s own words.

    A browser test now draws every state of a line with a call of every state under it, and compares each call with the same call on its own. @aparte/core

  • 4879492: Under React, Vue, Svelte and Angular, a scrolled conversation no longer moves up and down by a pixel while a reply streams reasoning.

    Nothing to change in your code. The space kept under a reply (so the question stays at the top) was written as a fraction and, under a wrapper, read back as that fraction against a scrollHeight the browser gives in whole pixels. It never settled: on every streamed delta that grew nothing on screen, a closed reasoning block in the reply or in a sub-agent’s transcript, it went 65.6, 66.1, 65.6 px, and the thread, held at the end of its scroll, moved a pixel each way for as long as the reply streamed (apartejs/aparte#270). The space is now whole pixels, so measuring it again with nothing changed gives the same value, in both modes; raw core also loses a one-pixel jump on the second measure.

    A browser test now reads every frame of a reasoning reply streaming into an already scrolled thread, on every example, at half a pixel. @aparte/core

  • 11895b0: Formulas in a sub-agent’s conversation under its line are drawn at their own pace again, instead of waiting on each other.

    Nothing to change in your code. A formula still arriving is drawn at most once a frame per reply part, and the part was found as a segment of the reply. A sub-agent’s text is drawn inside a segment of the reply (the line of the call that opened it), so every formula of its conversation, and of sub-agents writing at once, shared one pace: each answered null while another’s turn came. The part is now the nearest segment. @aparte/plugin-katex

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-subagents, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.16.0

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 4130c3e: <aparte-conversation-list> can move a conversation to another of your groups: set moveTargets, and each row’s menu offers “Move to…” and “Remove from “…””, a row can be dragged onto another group, and aparte-conversation-move tells you where.

    Nothing changes without moveTargets: the menu and the rows are the ones they were. Set it to the groups a conversation can go to ([{ key, label }], the shape an item’s group already has). “Move to…” lists every target but the row’s own group, in the same menu and walked by its keys; “Remove from “…”” takes a row in a group out of it; a row dragged onto another group (its heading or its rows) moves there, the group marked while a drop would land, and dropped on the rows of no group it leaves its group. Each sends aparte-conversation-move with { id, from, to } (to is a key, or null for no group), and the list moves nothing: you write it and assign conversations again. manage does not carry it out, since a group is your data. A target no row is in has no heading to drop on, so the menu reaches it. Under a wrapper, moveTargets is a prop or input and the event is onConversationMove in React, (conversationMove) in Angular, aparte-conversation-move in Vue and Svelte.

    Three locale keys, in the nine languages of @aparte/locales: moveConversation, moveConversationTo, removeFromGroup. The icon provider gains folder, which the “Move to…” item draws; folderIcon is still exported from @aparte/core/icons. @aparte/core, @aparte/locales

Patch Changes

  • 0ad9f5c: A reply, or a sub-agent’s conversation, no longer loses its last words when the server sends no text-flush before the next call or the run’s end.

    Nothing to change in your code. The stream parser holds a delta that ends on a backtick (or on the start of a block tag) until more arrives, and only text-flush handed it over. aparté’s own runner sends one at the end of every model call; a server loop of one’s own may not (apartejs/aparte#275). Then a reply ending on inline code lost it, and was saved that way: “La valeur est 42” in one delta showed nothing at all. The text is now handed over at every turn-start and at the run’s end (done, suspended, stopped), and a sub-agent’s at its own end and at the run’s; after a text-flush there is nothing left to hand over, so nothing appears twice. The server-loop guide’s wire example closes each call with text-flush. @aparte/core, @aparte/plugin-subagents

  • 0448d6f: <aparte-model-selector> lists the new models when a provider is replaced while it is on screen, instead of an empty list or the old models.

    Nothing to change in your code. An app that replaces its model catalogue (unregisterAIProvider(id), then registerAIProvider(createModelCatalogue({ id, ... })) with the new models) saw an empty picker: the second change was compared with the list loaded before the first one, taken for no change, and the load the first one had started, which saw no provider, wrote an empty list (apartejs/aparte#276). A change that comes while a load runs now makes that load go round again. And a provider registered again under the same id, a catalogue whose models changed, now reloads the list: the selector compared provider ids only, and kept the old models. A fresh id per catalogue, the workaround, is no longer needed. @aparte/plugin-model-selector

Version-only bumps (no changes of their own): @aparte/engine, @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-artifacts, @aparte/plugin-ask-user, @aparte/plugin-cards, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-diff, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/docs-mcp.

1.17.0 Latest

Every @aparte/* package ships at this version (they are released in lockstep).

Minor Changes

  • 3a59a20: A message the server refuses for its size (HTTP 413) now reads “This message is too large to send. Remove a file or send a shorter one.” instead of promising a retry, and is left out of later requests.

    AparteError.codeForStatus had no case for 413, so the error fell back to a failing provider: “Try again in a moment”, and a retry sends the same bytes. It is easy to hit: nginx refuses a body over 1 MB by default, PHP one over 8 MB, and an image travels in base64. It has its own code now, USAGE_TOO_LARGE, its own sentence, errorTooLarge, in the nine languages of @aparte/locales, and it joins the codes whose message is left out of every later request: a long pasted text refused for its size no longer goes out again with the next message and takes it down too. (apartejs/aparte#294) @aparte/core, @aparte/locales

  • 118707f: A sub-agent opened by another sub-agent, saved while it waited for an approval, now goes on on its own line in its parent’s transcript when the reply is resumed after a reload.

    Its saved line was looked for in the reply’s own segments only, so its resumed work was dropped, or went to a second, top-level line, and its call stayed awaiting approval. The plugin now finds it at any depth and takes up the sub-agents it sits under first. createSegmentList gains a paused option for that: a saved list taken up as a pause keeps its calls waiting for an approval open, where history aborts them. @aparte/core, @aparte/plugin-subagents

  • 6d1f934: A conversation row can say its turn is queued: setConversationStatus(id, 'queued') (or aparte-conversation-status with status: 'queued') draws a muted mark, no shimmer, and “Queued” for a screen reader.

    For a turn sent but waiting behind another conversation’s: a local engine that serves one turn at a time, a backend’s queue. Read as running, the row shimmered and said “Answering” while nothing was being written. Only the app knows a turn is queued, so the app says it, and says running once the turn is served; the conversation controller’s running at the turn’s start no longer takes a queued back. AparteConversationStatus gains 'queued': a host that matched every status exhaustively has one more to handle. The new locale key conversationQueued is translated in the nine languages of @aparte/locales. (apartejs/aparte#289) @aparte/core, @aparte/locales

  • 608fb2c: A conversation can be dragged from one <aparte-conversation-list> onto another: give each list the key of the group it stands for in drop-key (dropKey). The drag type is public: APARTE_CONVERSATION_DRAG_TYPE.

    For an app that renders one flat list per project under headings of its own. A list’s rows with no group are in its key’s group, a row dropped on it moves there, from another list of the page or from an element of the app’s own that carries the type, and a row dropped back on its own list moves nothing. A list with no rows still takes a drop. The move is the same aparte-conversation-move, sent by the list the row lands on, from the key of the list it came from. Without drop-key, nothing changes. (apartejs/aparte#278) @aparte/core, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

  • 6db770f: A step can say what it is about: step-start carries a detail, a new step-update { name, detail } changes it while the step stays open, and the step’s label function is handed detail and the reply’s messageId.

    A server waiting for a slot of a local engine knows who holds it, and the words belong to the page. A step carried its name alone and its label saw only that: an app kept the last holder in a module of its own, ended and restarted the step to have the words asked again, and two chats waiting showed the last one told. The detail travels with the step to the reply’s waiting indicator and to a sub-agent’s line, and the label is asked again when it changes. A second step-start of the same name still opens a nested step, as AG-UI’s rule says: update a step with step-update. (apartejs/aparte#288) @aparte/core, @aparte/engine, @aparte/plugin-subagents

  • 6d5eab5: A sub-agent heard before it names the call that opened it (an AG-UI agent whose first event arrives before SUBAGENT_STARTED) now moves onto that call: one line with all it said, and nothing marked Stopped.

    It got a line of its own first, as a sub-agent with no call does. Announced again with its call, it was taken for another sub-agent under the same id: the first line read Stopped and what it said was split across two lines. createSegmentList gains removeSegment, so a sub-agent’s own transcript can take a line out as a reply can. @aparte/core, @aparte/plugin-subagents

  • 85ea6eb: New showToast(text, { tone, timeout, target }) in the kit: a short message in a corner of the page that goes away on its own.

    For what has nowhere else to be said, such as why an action did not happen. It is the kit’s alert, stacked in a fixed corner that never moves the layout under the pointer. It is announced as a status, or as an alert in the danger tone, waits while it is hovered or holds the focus, and closes by its button or Escape, giving the focus back to where it came from. Shown while a modal dialog is open, it goes inside the dialog, since everything outside one is inert; for a design system’s dialog drawn in its own shadow root, it goes in the page’s own content the dialog shows, where the kit’s stylesheet reaches it. target names the element it is about: the toast goes in that element’s shadow root and wears its theme. It returns a handle with close(), and does nothing in a server render. Two locale keys name its region and its button (notifications, dismissNotification), in the nine languages. (apartejs/aparte#279) @aparte/core, @aparte/locales

  • dd2fce8: A tool can set its own time limit (timeoutMs on the tool), which replaces the client’s or the server handler’s toolTimeoutMs for that tool; Infinity means no limit.

    A tool that runs a whole sub-agent on a slow local model, or a command with a limit of its own, was cut at five minutes like a lookup, and a host that raised the shared bound to spare it lost the bound for every other tool. Infinity, or any delay above 2^31-1 ms, used to fire at once (a timer reads such a delay as zero): it is no limit now. A sub-agent a call opens in the background is bounded by that call’s limit. The docs now say what happens when a limit fires: the call is abandoned and the run stops, since a handler that ignores its signal may still be running. (apartejs/aparte#290) @aparte/core, @aparte/engine

  • 6075c93: An approval policy can rule asynchronously: setApprovalPolicy and the server handler’s approvalPolicy may return a promise, awaited before the call runs, pauses or is refused.

    Security fix included: a policy that returned a promise used to let every call run unasked in the page (the promise was taken for a ruling with no verdict, so the gate opened, needsApproval tools included), and was ignored on the server, where a deny on a tool with no flag let the call run. While a policy rules, the calls the model made after that one wait, as they wait for a person’s answer, so the order guarantee holds; a synchronous policy stays synchronous. A promise that rejects asks a person, with the reason on the console. A policy is asked once per call, so the ruling that paused a call is the one that answers it, and a Stop does not wait for a ruling still on its way. config.ruleOnToolCall stays synchronous and answers ask for a policy still ruling; the new config.ruleOnToolCallAsync waits for it. The engine’s needsApproval predicate may answer with a promise too. (apartejs/aparte#291)

    Code that CALLS a policy (one that wraps config.getApprovalPolicy() to compose two) now gets a type whose answer may be a promise: await it, or ask config.ruleOnToolCallAsync. A policy you write is unaffected, and createApprovalPolicy from @aparte/plugin-approval is still typed as ruling at once. @aparte/core, @aparte/engine

  • 2ba627d: new AparteConversationManager(adapter, { orderBy }) orders its lists as the app chooses: 'updated' (the default, unchanged), 'created', or a compare function.

    The lists were by updatedAt, the last change of content: a reply that ends moves its conversation up, as most chat products do. An app that keeps a conversation in its place, or orders by the person’s last message, sorted the manager’s lists again itself. A conversation list’s date groups still read each row’s updatedAt: with another order, hand it the date you order by. Opening, renaming or reloading a conversation never moved it, and still does not. The framework helpers’ lists (useConversationManager in React and Vue, Angular’s ConversationManagerService, Svelte’s createConversationManager and createConversations) follow the same option, given to their init; manager.compare(a, b) sorts a list of the app’s own the same way. (apartejs/aparte#293) @aparte/core, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

  • 8783037: A sub-agent whose own run stops before it answers (its turn limit, a call it could not make) now ends partial, with a reason and what it found as its result, and its line reads “Cut short” instead of Done.

    runSubAgent reported every such sub-agent as done with its last text, often empty after a round of tool calls, so the parent model read a finished answer and the line said Done above a transcript showing the turn limit’s error. StreamAgentStatus and AparteSubagentStatus gain 'partial', agent-end gains reason (a StreamAgentCutReason: turn-limit, timeout, no-handler, no-resolver, aborted for a call that stopped itself, or context for a host’s own loop), runSubAgent returns them, and a background sub-agent cut short is reported to the model as such. aparte-subagent-end carries the reason too. A host that matched every status exhaustively has one more to handle. (apartejs/aparte#285) @aparte/engine, @aparte/plugin-subagents

  • 1f24530: A sub-agent can name the model it runs on: agent-start carries model, runSubAgent and startSubAgent fill it from their request (or take a model you give), and setupSubagents({ model: true }) draws it quietly on the sub-agent’s line.

    A host whose sub-agents run on other models than the conversation (a small local one beside the main) had only the name to show it, “Reader · qwen3:8b”, which a host matching lines by name then had to strip. The model is kept on the segment, so a thread read back still says it. Off by default: every existing line would change. aparte-subagent-start carries it too, as model. (apartejs/aparte#286) @aparte/engine, @aparte/plugin-subagents

Patch Changes

  • e1685e0: Escape and Tab typed in a field of a web component inside a modal dialog are the dialog’s again: an open drawer or the launcher no longer takes them.

    The drawer and the launcher leave a modal dialog’s keys to it, and looked for the dialog around where the key began with closest(), which stops at the edge of the component’s own shadow root: the drawer closed, or the launcher hid the chat, on the dialog’s Escape. They now look along the key’s whole path. @aparte/core

  • aee4d0c: A dialog opener or closer made of a web component (a Shoelace or Material button, or a button holding an icon component) opens and closes its dialog again.

    Since the dialog wiring learned to work inside an app’s shadow root, it read the click from where it began and looked for the control with closest(), which stops at the edge of the shadow root it starts in: a click on the label or the icon of a component button, each in the component’s own shadow root, found no opener. The control is now looked for along the click’s whole path, across every shadow root it crossed. @aparte/core

  • 3c2d7e3: In Safari, dragging text or a link out of the transcript no longer leaves the chat unable to follow the next reply to the bottom.

    The transcript holds a press from pointerdown to the next pointerup or pointercancel, and WebKit sends neither after a native drag. The press stayed held for the rest of the turn, and the engine’s own settle at the end of a reply read as the reader scrolling up, which stopped the follow. A drag now ends the press, as it already does in the conversation list. @aparte/core

  • adeaffe: A key that leaves <AparteUi>’s props is now cleared on the element: its attribute or CSS variable is removed, and its property is set to undefined.

    With the usual { ...(fetching && { loading: true }) }, the next bag has no loading once fetching ends, and only the keys present were written, so the attribute stayed and the skeleton rows never went away, in all four wrappers. applyElementProps takes { replace: true } for a bag that is the element’s whole set of props; without it, as the generated components call it with only what changed, an absent key is left alone. @aparte/core, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

  • 6962a28: A reply cut by an error keeps its last words: the text the parser was holding (the end of a code block, a closing backtick) is no longer lost.

    The engine flushes the call’s text before it throws, and the client flushes on its error path too, for a runner of your own that does not. @aparte/core, @aparte/engine

  • 5ed682c: A reply streamed by hand through a framework chat (appendToSegment in a loop) is written incrementally again, chunk by chunk, until isStreaming: false ends it.

    Since 1.16’s fix for edited replies, a segment with no isStreaming flag followed the bubble’s streaming attribute, and every wrapper drops that attribute as soon as a reply driven by hand has a segment. Each chunk, and each frame’s re-sync, then closed the stream and drew the whole text again: an unclosed ** showed raw, and a highlighter, a diagram or a formula ran once per token. An append is now a stream whatever the attribute says, and a stream already open goes on until a flag ends it. A bubble with streaming="false" now reads as not streaming, as the bubble itself reads that value, so an edit of its finished reply is written whole. @aparte/core

  • a6ed3a6: Under React, Vue, Svelte or Angular, a reply you write by hand into an empty assistant message now streams until you give it a status, as it already did without a framework: end it with updateMessage(id, { status: 'completed' }).

    The bring-your-own-loop flow (appendMessage with no status, addSegment, appendToSegment, then a status) lost its stream as soon as the first segment arrived when the empty bubble had been painted first, which any real wait before the first token causes: a wrapper draws a bubble’s streaming from isAwaitingReply, which a segment turns false, and the bubble took that for the reply’s end. Every chunk after it was drawn whole, an unclosed ** showed raw, and a reasoning block read finished while it was still being written. The host now marks such a shell streaming when its first segment is written, and the status the app gives it ends it. A reply that already had words when a segment was added keeps the status the app gave it. @aparte/core

  • 2ce599e: A Stop pressed just as the reply ends no longer sends the message the person had drafted for later.

    The reply could end between the press and the release: the same button turned back into Send, and the click sent the unfinished draft. A click now does what the button showed when it was pressed, so a Stop with nothing left to stop does nothing. The keyboard already refused it, since Enter neither sends nor stops during a turn. @aparte/core

  • de4b389: A modal dialog placed inside <aparte-sidebar> keeps its Escape and Tab while the sidebar is a drawer: the drawer no longer closes behind it.

    A settings dialog put beside its button in the sidebar was taken for the drawer’s own content. Its Escape closed the drawer, which then made itself inert with the open modal inside it, so the page could not be used until a second Escape; Tab from the dialog’s last button went nowhere. A modal dialog anywhere on the key’s path now has the key, as one outside the sidebar already did. @aparte/core

  • a96cbe2: After a reload, resuming a reply paused on a sub-agent’s call no longer tells the model the call that opened the sub-agent was stopped.

    @aparte/plugin-subagents marks that call awaiting-approval while the sub-agent’s question is up. Loading the reply turned it into aborted, so the resume answered it “The tool call was stopped before it ran.” for a delegation whose sub-agent was about to go on, and its line read Stopped. In a reply paused on deferredCalls no gate of the page is open, so a waiting call is kept open and the resume hands it back open. @aparte/core

  • 41bcabe: A property input given undefined, null or false now clears the element’s property: [moveTargets]="canMove ? groups : undefined" in Angular, or a key kept in an <AparteUi> bag with no value (moveTargets: canMove && groups).

    Only the attribute of the same name was removed, and the element went on with the old array or function: rows kept offering “Move to…”, an old renderMeta kept drawing. A key given an object or a function before is a property, and is cleared as one. @aparte/core, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue

  • c510994: A property given to an element before its definition loads (a lazily imported plugin’s diff, comments, chat, triggers) now reaches the element once it is defined.

    <AparteUi> and the wrappers’ generated elements assigned it right away, so it became the element’s own property and hid the setter the definition brought, for good, although the docs promise a tag mounted before its definition upgrades on its own. The value is now kept and handed to the setter when the element is defined. @aparte/core

  • a642064: Clicking a scroll-rail tick in a chat embedded in a scrolling page now scrolls only the transcript, not the page around it.

    The jump used scrollIntoView, which aligns the message in every scrolling ancestor, the page included. In a dashboard panel or on a docs page, each tick moved the whole page and pushed the chat’s own header out of view. The transcript’s surface is now scrolled by the distance to the message. @aparte/core

  • 27bd996: A framework chat’s re-sync now carries every field a segment changed, a text segment’s included, and a change the app wrote in place on the segment it handed over.

    A reasoning block’s label, a code block’s language, an error’s details reached the bubble only when the segment was drawn anew: for a segment with text, only the text was patched. And a field written in place (seg.status = 'resolved', idiomatic in Svelte and Vue) was compared with the bubble’s copy, which is the same object, so a resolved call kept reading as running. Each re-sync now compares with what was last handed over. @aparte/core

  • 53b3347: Renaming a conversation with an input method (Japanese, Chinese, Korean) no longer commits or cancels the rename on the Enter or Escape meant for the word being composed.

    Enter confirms a candidate and Escape cancels a composition. Firefox sends them flagged isComposing, and Safari sends that Enter after the composition with keyCode 229. The list took both for its own: the title was saved half converted, in the middle of the word, or the rename was thrown away. @aparte/core

  • c44971e: In controlled mode (messages and onMessagesChange), a tool call’s new status or result, a card’s new data, and any other segment without text now show when the parent hands the message again.

    When the message kept the same number of segments, the wrappers’ re-sync patched only segments carrying content: a call the parent marked resolved kept spinning “Running”, and a segment replaced under another id was ignored. The fields a segment changed are now patched, and a replaced segment draws the bubble again. @aparte/core

  • 628e1ce: An open <aparte-select> (the model selector, the approval mode) now answers only the keys typed in it, and Tab closes it.

    It listened on the whole document: open, it took Enter, the arrows and Escape typed anywhere. Tab back to the composer left it open, and Enter there sent the message, then also switched the model. Its Escape also came after every listener on the way up, so inside a launcher the whole chat closed on the Escape meant to dismiss the list. @aparte/core

  • aa39bb9: The server handler keeps a failed sub-agent’s error text on the server: the page reads “The sub-agent failed.”, and the real message goes to the server’s log.

    A sub-agent that failed on a server tool’s error (a path, a connection string) or on its model’s (a vendor message that can echo a key) ended with that text in agent-end’s error, which went out as it was: the page drew it on the sub-agent’s line and the conversation saved it. A tool’s own failure was already masked this way; the sub-agent’s end now is too. @aparte/core

  • 1174c83: A tap on a kit menu item (a row’s Rename, Pin, Delete) now keeps the menu open until the tap’s click lands.

    The menu closes when the focus leaves for nowhere unless a press inside it is under way, and that press ended at pointerup. On a touch screen the tap’s click comes after the finger is lifted, and on iOS so does the compatibility mousedown, which blurs the focused item: the menu could close before the click reached the item. A touch press now lasts until its click, or 600 ms if none comes. iOS’s event order was not measured here; the change leaves mouse presses as they were. @aparte/core

  • cfef2ed: A tap on a conversation row while the app updates the list now selects that row.

    The list holds the app’s render during a press so a row is not replaced under it, and lifted the hold one task after pointerup, where a mouse click already landed. A tap’s click comes later, so the held render could replace the row under the finger first. A touch press now holds the render until its click, or 600 ms if none comes. @aparte/core

  • da08615: Setting value on <aparte-select> from code no longer fires aparte-select-change; only a choice the person makes does. If you relied on the event after setting value yourself, run your handler there.

    The attribute set the value silently and the property announced it, so the same app echoed under Vue, Svelte 5 and a raw tag (which write the property) and not under React’s element or Angular’s directive (which write the attribute): a value loaded from a saved conversation came back as a change, and a handler saving the person’s choice saved one nobody made. Both paths now behave as a native <select>. <aparte-approval-mode> relays only that event, so a mode set by code (getApprovalController().setMode(...) on a switch of conversation) no longer comes out as aparte-approval-mode-change either. (apartejs/aparte#295) @aparte/core

  • 7e83934: Enter or Space on the Send button sends again after a press on Stop that never became a click (the pointer slid off before the release, or a touch turned into a scroll).

    The button remembers what it showed when it was pressed, so a Stop released just after the reply ended does not send the draft. That record outlived a press that produced no click, and the next activation from the keyboard was read as that Stop: the draft was not sent until a second press. The record now only counts for a click a press produced. @aparte/core

  • c3eb2f9: Editing a finished reply in place (updateSegment with new text) now draws the whole text, its last characters included.

    A segment with no isStreaming flag (every restored one) was read as still being written on update: the incremental parser wrote it and held back its tail, and nothing ended it since the bubble never streamed. A missing flag now follows the bubble: still writing while it streams, finished when it does not. @aparte/core

  • bd46542: An Escape that cancels a word being composed with an input method (Japanese, Chinese, Korean) no longer closes a diff comment or a message edit, and no longer drops what is being written.

    The diff’s comment field took every Escape as its own and let go of the form. The bubble’s inline edit checked isComposing, which Safari does not set on the key it sends after a composition ends (keyCode 229). Both now leave a composition’s keys to the composition, as the composer, the rename and the select already do. @aparte/core, @aparte/plugin-diff

  • e513b1f: The kit’s dialog attributes (data-aparte-dialog-open, data-aparte-dialog-close, the backdrop click) now work inside an app’s own shadow root.

    A click from a shadow root reaches the document with the shadow host as its target, so the opener and the closer were never found, and the dialog was looked up in the document, where it is not. The click is now read where it began, and the dialog is found in the opener’s own root. @aparte/core

  • ed45742: Enter opens a closed <aparte-select> from the keyboard, and ArrowDown opens it on the selected option; neither chooses anything on the way.

    The keydown that opened the list went on up to the select’s own key handler, which found the list open with the selection active: Enter chose it again and closed the list at once, firing aparte-select-change with the same value, and ArrowDown moved one past it. Only Space opened a select. Also, an Escape typed while the focus is on the page, the list open inside a drawer, now closes the list and leaves the drawer open: the select hears that key before any listener on the page. @aparte/core

  • 8d2b64a: Resizing the window or the chat no longer raises “ResizeObserver loop completed with undelivered notifications” from the composer.

    The editor set its own height inside the observer that watches it, so each width change (a window resize, the launcher maximized, the drawer toggled) ended in that browser error, which monitors log for every user and dev servers show full screen. The height is now set on the next frame, and only when the width changed. @aparte/core

  • b4f313a: Removing an attachment from the keyboard now leaves the focus on the next file’s remove button, or in the editor when none is left, instead of on the page.

    The strip is drawn again whole on every change, so the focused remove button was destroyed and the next Tab started again at the top of the page. A file added while a remove button has the focus keeps it on that file. @aparte/core

  • 523ceef: In a right-to-left chat, a tool row’s opened detail and a reasoning block now put their indent beside their rule, on the right.

    Their rule is border-inline-start, the right edge in a right-to-left chat, but the indent came from physical shorthands that set the left padding, so the Input/Output panels and the reasoning text sat flush against the rule with an empty strip on the other side. The rename field in the conversation list had the same mismatch. All four now use logical properties. @aparte/core

  • 3fbaf76: In a right-to-left chat, a reasoning block written in English keeps its indent beside its rail, and the compact weather card and the link chip pad the right side.

    The reasoning panel reads its own direction (dir="auto"), so English reasoning in an Arabic chat put its indent on the left while the rail, which follows the chat, is on the right. When the two directions differ, the indent now goes on the rail’s side. The weather card’s extra space for its accent bar and the link chip’s tighter icon side were physical paddings: they are logical now. @aparte/core, @aparte/plugin-cards

  • 1902a42: Text a model writes after a tool call, in the same model call, now appears after the call’s row instead of being appended to the text above it.

    The adapter hands over the text before a call, as it already did around an activity and as the AG-UI and n8n runners do. Seen with @aparte/provider-scenario and with Gemini through the AI SDK. @aparte/core

  • c7334d0: The open sidebar drawer now leaves Tab and Escape to a modal dialog opened above it, and to a word being composed in its search field.

    A dialog opened from the drawer (the kit’s data-aparte-dialog-open pattern) had Tab pulled back into the drawer it covers, so Tab did nothing, and Escape closed the drawer behind the dialog. The Escape that cancels an IME composition in the drawer’s search field closed the whole drawer. @aparte/core

  • edce799: Pressing the scroll-to-bottom button from the keyboard now moves the focus to the transcript as the button hides, instead of leaving it on a hidden control.

    At the bottom the button turns transparent, leaves the tab order and is marked aria-hidden, but it kept the focus. A screen reader was left on a node removed from the tree, a keyboard user had no focus ring, and Space kept pressing a control nobody could see. @aparte/core

  • 33e80e4: Two tool calls of one reply now keep two rows, even when a later model call repeats an earlier call’s id.

    A vendor that sends no call ids has them minted per stream (openai-compat), and a server that numbers ids per response repeats them: the second call’s result was written onto the first call’s row, the second row stayed pending, and the next request filed both answers under one id. A repeated id is now renamed for the whole reply (aparte-call-1_2), the calls a resumed run made before its pause included. An earlier reply’s ids are left alone. The suffix is _, not #: Anthropic takes only [a-zA-Z0-9_-] in a call id, and a history replayed to it after a change of model must not carry a #. @aparte/engine

  • c4b8933: Two tool calls a server sends at the same index with different ids are now two calls, each with its own arguments.

    A server that numbers index per chunk rather than per response sends every call at index 0 (Ollama’s /v1 has been seen to). The second call was taken for the rest of the first: one call, run with the second’s name on {}, and the first lost. A named delta with a new id now opens its own call when the index is held by a call with another vendor id. A call opened by index whose real id arrives later is still one call. @aparte/provider-openai-compat

  • 8ed00af: A scenario whose reply delegates twice under the same id, in two turns, now runs the second sub-agent too.

    The loop names a call once per reply, so the second turn’s call is id_2. The scenario filed its scripts per turn, the second one under id, and its handler, asked for id_2, answered “No script exists for this call”. The scripts are now named by the same rule as the loop’s, seeded with the calls already in the reply. @aparte/provider-scenario

  • a4a4a07: A scripted sub-agent cut short is reported to the parent model as cut short, with what it found.

    The delegate tool’s report knew only done and failed: a sub-agent that ended partial (its turn limit, a call it could not make) read “was stopped before it answered” and its text was dropped, while its line said Cut short. @aparte/provider-scenario

  • 84b6aee: createApprovalPolicy is typed as ruling at once, so policy(call)?.verdict reads without an await.

    A core approval policy may now answer with a promise (apartejs/aparte#291), and the factory’s return type used to be that wider policy type, so reading the mode’s ruling by hand stopped typechecking. The policy it builds never was asynchronous; its type now says so, and it is still accepted by setApprovalPolicy. @aparte/plugin-approval

  • 74ba274: An Escape that ends an IME composition in a field inside <aparte-subagent-view closable> or <aparte-artifact-panel> no longer closes the pane.

    A Japanese or Chinese reader cancelling a conversion candidate in a field inside the pane (a diff comment, say) folded it mid-composition: the field now leaves that Escape to the composition, and the pane read it as its own. @aparte/plugin-artifacts, @aparte/plugin-subagents

  • 5aafbdc: A sub-agent announced with no call, under the id of one that already finished, now gets its own line instead of writing over the finished one’s.

    A backend that mints sub-agent ids per run (the engine’s default counter) names a resume’s first detached sub-agent like the paused run’s. A finished sub-agent never resumes, so its id announced again is a new one; only one left waiting or running goes on. @aparte/plugin-subagents

  • 89fa900: A nested sub-agent’s conversation now shows both in the chat and in a view of its parent beside it, instead of moving between the two.

    With details: 'transcript', the nested sub-agent’s line is drawn inside its parent’s transcript in the chat, and again in the view where the parent is opened. Both rows got the one element kept for that sub-agent, so each update moved it into the row that asked, and one of the two was always empty while it wrote. A view of its own now keeps its own elements. @aparte/plugin-subagents

  • e93fd76: Changing the language, the icons or a tool while a sub-agent is open in a view no longer empties the nested sub-agent’s conversation in the chat.

    The view relabelled its rows outside its drawing, with no surface: a nested sub-agent’s row in the view asked for the chat’s element of that conversation, and moved it into the view. The chat’s row stayed empty until it was drawn again, which after the run’s end may never come. Every pass over a view’s rows now runs on that view’s surface, a line’s detail on the surface it sits in. @aparte/plugin-subagents

  • 1e5b147: After a reload, the call that opened a sub-agent reads as working again once the sub-agent’s question is answered, instead of staying “awaiting approval”.

    While a sub-agent asks, the plugin marks the call that opened it as waiting and gives it back its progress once the question is answered. A lane taken up after a reload did not know the mark was its own, and left it. @aparte/plugin-subagents

  • 8963bfe: A sub-agent saved while it waited now goes on, on its own line, when the reply is resumed after a reload, whether the resumed stream announces it again or not.

    After a reload the plugin knew no lane. Events for a sub-agent the resumed stream did not announce again were held until an announcement that never came, then dropped: the transcript kept a call that ran as waiting, then Stopped. Announced again with no call, the sub-agent got a second, empty line. The saved line is now found by the sub-agent’s id, on its call or on a segment of its own, while it was waiting or working. @aparte/plugin-subagents

  • 28327d1: A view disconnected from its chat, or shown a new conversation, follows the sub-agent it is named again, on whatever call it runs.

    connectSubagentView keeps a view on the call of the line pressed, since two sub-agents of one reply can share an id. That filter outlived the connection and the conversation: a sub-agent named on the view afterwards, on another call, was never drawn live. @aparte/plugin-subagents

  • a76de60: Open on the second of two sub-agents that share an id and have no call now shows that second one, and only its line reads as shown.

    Since each such sub-agent has a line of its own, the view still told sub-agents apart by the call of the line pressed, and these lines have none: Open showed the first, and both lines were marked current. A line of its own is now told apart by its own segment. @aparte/plugin-subagents

  • 4a838b8: Open on a sub-agent’s line now shows that sub-agent in the view, even when another sub-agent of the reply has the same id.

    A backend that mints sub-agent ids per run names a resume’s first one like the paused run’s. The view took the first sub-agent under that id, drew the other’s writes over it while it ran, and both lines read as the one shown. connectSubagentView now hands the view the call of the line pressed, and only that line is marked. @aparte/plugin-subagents

  • 6d54761: A mention list asked of a function now loads while the app re-renders, instead of never arriving during a streaming reply.

    A wrapper writes triggers on every render, with a new array, and a chat re-renders on every token. Each write aborted the request and armed the debounce again. The same search, asked of a function, is no longer asked again. @aparte/plugin-triggers

  • 5ca9066: A trigger source handed anew while its list is open (a memoized declaration recomputed for another channel) is asked again, once the declarations stop changing.

    Since the fix that keeps a list arriving while the app re-renders on every token, a new function for the same search was never asked: the first channel’s members stayed listed, and Enter inserted one of them. The answer on its way still arrives while the app re-renders, however slowly it re-renders and however slow the source is: a re-ask never aborts it, and the newest source is asked once that answer is in. @aparte/plugin-triggers

  • 6d54761: Enter while a new search is loading now chooses a row that matches what is typed, never one left from the search before.

    With a list asked of a function, the rows on screen stayed the previous search’s until the new answer arrived: “@car” and Enter took Alice, the row active for ”@”. Until the answer arrives, only the rows that still match stay. @aparte/plugin-triggers

  • 9f95728: In Angular, an unset binding of an input that is on by default ([elicitation], [submitOnEnter], a launcher’s [header], a file picker’s [multiple]) now keeps it on, as in React, Vue and Svelte.

    Angular’s booleanAttribute(undefined) is false, so binding a field that is not always set turned the default off: no question presenter (every call needing approval aborted with nothing to click), Enter inserted a newline instead of sending, the launcher lost its header, and the picker took one file. undefined and null now leave the element on its own default. @aparte/angular

  • bd02072: A plugin component mounted before its element is defined (the spec imported at once, the element’s module loaded later) now hands its properties to the element once it is defined.

    The generated component assigned each property straight onto the element. Before the upgrade, that made it the element’s own property, which hid the setter the definition brought, for good: the element rendered empty. It is held until the tag is defined, as core already does for <AparteUi>. @aparte/react

  • 7633cb9: Calling the conversation helper’s init() again while the first one is still loading no longer ends with the first manager registered on the config.

    With a slow store (a remote one with a long history) and an account switch, the first init() resolved after the second and registered its manager last, so the chat persisted into the store of the account just left. A superseded init() now registers nothing. Angular’s service already read its current manager and kept the newer one. @aparte/react, @aparte/svelte, @aparte/vue

Version-only bumps (no changes of their own): @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-transformers, @aparte/plugin-ask-user, @aparte/plugin-chartjs, @aparte/plugin-compaction, @aparte/plugin-echarts, @aparte/plugin-katex, @aparte/plugin-marked, @aparte/plugin-mermaid, @aparte/plugin-model-selector, @aparte/plugin-shiki, @aparte/plugin-storage-idb, @aparte/plugin-streaming-markdown, @aparte/plugin-titler, @aparte/docs-mcp.