Skip to content

1.5.0

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

Minor Changes

  • 50014a4: A sidebar in the shell of an <aparte-launcher> card is now a drawer in that card, and <aparte-conversation-list target="…"> drives one chat. To keep a column in the card, set breakpoint="none" on the sidebar.

    • A sidebar in the floating chat followed the window’s width: in a wide window it stayed a column inside a card a few hundred pixels wide, and as a drawer it opened over the page the chat floats on. As the direct child of the card’s .aparte-app-shell, it is now a drawer in the card, its scrim covers the card, and it is a column again once the chat is maximized (not with maximizable="panel", which is still narrow). Escape closes the drawer before it closes the chat, and closing the chat closes the drawer.
    • A shell as the card has the card’s height. .aparte-app-shell directly inside <aparte-launcher> was as tall as what it held; it now takes --aparte-launcher-height, like any other card.
    • A sidebar toggle that names no sidebar drives the one of its own shell. data-aparte-sidebar-toggle in a shell’s header opened the first sidebar of the page, which is not its own on a page with two shells.
    • Escape on a row’s menu inside an open drawer closes the menu and leaves the drawer open; it closed both.
    • target on <aparte-conversation-list>: the id of the chat the list drives. A row’s click then carries targetId in aparte-conversation-select, so only that chat opens the conversation; on a page with two chats, every chat used to. And manage acts on that chat’s conversation manager, where a list beside a chat that has a configuration of its own found none.
    • AparteConversationSelectDetail gains the optional targetId. @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-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/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.6.0

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

Minor Changes

  • 570cdcc: An approval asked for a sub-agent’s call now names the sub-agent: “Allow read_file for Researcher?”, from the new locale key approvalAskBy.

    approvalAskBy is Allow {tool} for {agent}?, {agent} being the name the sub-agent was started with and {tool} what approvalAsk puts there. @aparte/locales carries it in its nine languages; a locale of your own that lacks it falls back to English, and extendLocale({ approvalAskBy: '…' }) sets it. A sub-agent with no name is asked about with approvalAsk, as before. aparte-tool-approval-request carries the call’s agentId when a sub-agent asks. @aparte/core, @aparte/locales

  • 570cdcc: A tool can now open a sub-agent: call runSubAgent(context.run, { name, request }, signal) from its handler, in the page or on the server.

    ts
    import { runSubAgent, type AparteToolHandler } from "@aparte/core";
    
    const research: AparteToolHandler = async (call, signal, context) => {
      const answer = await runSubAgent(
        context!.run!,
        {
          name: "Researcher",
          request: {
            modelId: "gpt-4.1-mini",
            messages: [{ role: "user", content: String(call.input["question"]) }],
          },
        },
        signal,
      );
      return { toolCallId: call.id, content: answer.text };
    };
    • The run a tool is called in. A handler now gets the run as a third argument (StreamToolRun in @aparte/engine, context.run, typed AparteToolRun, in @aparte/core). A handler written with two parameters is unchanged. A browser tool answering a paused server run has none.
    • runSubAgent. Runs a loop of its own on the conversation you give it, with the run’s model connection, tools and limits unless you pass others, and resolves { status, text, error? }: done, failed or stopped, and what the sub-agent wrote last. It never rejects for a sub-agent that failed, so the tool decides what the model reads. detached: true gives one of several sub-agents opened by the same tool a line of its own. run.startAgent() announces a sub-agent by hand and returns a StreamAgentHandle (emit, end).
    • New run events. agent-start (agentId, name, description, toolCallId, parentAgentId) and agent-end (agentId, status, result, error), and an optional agentId on every event that is not one of the four run-*: the event is that sub-agent’s. A sub-agent ends with the call that opened it, before the call’s own end: stopped on a Stop, the call’s timeout, or a handler that returns with it still open (an un-awaited runSubAgent), and failed, with the handler’s message, when the handler throws. Its handle emits nothing after that.
    • Approvals. A sub-agent’s call that needs a decision is asked through the run’s resolver, with call.agent naming the sub-agent. In a run that pauses instead of waiting (deferral, the server loop), it cannot ask: the call is aborted with the cause no-resolver.
    • Hearing a run. config.observeRunEvents(observer) (AparteRunEventObserver, AparteRunEventContext) hears every event of a reply’s run, its sub-agents’ included, before the reply handles it, and returns the function that removes it.
    • Server loop. createAparteAgentHandler mints the ids of the sub-agents it runs so they never repeat from one request to the next: the resume of a paused reply no longer names its first sub-agent like the paused run’s. @aparte/core, @aparte/engine
  • 9c3de09: A tool can now start a sub-agent in the background and let the chat go on: call startSubAgent(context.run, { name, request }) from its handler and return at once.

    ts
    import { startSubAgent, type AparteToolHandler } from "@aparte/core";
    
    const research: AparteToolHandler = async (call, _signal, context) => {
      startSubAgent(context!.run!, {
        name: "Researcher",
        request: {
          modelId: "gpt-4.1-mini",
          messages: [{ role: "user", content: String(call.input["question"]) }],
        },
      });
      return {
        toolCallId: call.id,
        content: "The researcher is on it; its answer comes back to you.",
      };
    };
    • While it works, the model goes on writing and calling its own tools, and the sub-agent has a line of its own. The reply does not end before it is back: once the model has nothing more to say, the loop waits for the sub-agents still at work, tells the model how each ended in one user message, and asks it again.
    • It stops with the run: Stop, the turn limit, the tool time limit counted from its start, or a crash.
    • Not in a server loop: a run that can pause would end at the pause without what it answered, so startSubAgent throws there (run.canBackground is false); use runSubAgent.
    • What the model was told stays in the run: the next turn’s history is drawn from the reply, so it holds the model’s answer to the sub-agents, not the message that told it how they ended.
    • runSubAgent is unchanged: it holds its call until the sub-agent is back.
    • In the engine, StreamToolRun.startAgent takes background, StreamToolRun gains canBackground, and StreamAgentHandle gains signal, what its work answers to.
    • In @aparte/provider-scenario, a subagents step takes background: true: the next scripted turn plays while they work. @aparte/core, @aparte/engine, @aparte/provider-scenario
  • 570cdcc: A sub-agent’s text and tool rows no longer show inside the reply; add @aparte/plugin-subagents to show one line per sub-agent.

    ts
    import { setupSubagents } from "@aparte/plugin-subagents";
    
    setupSubagents();
    • What you see without the plugin. The reply holds the agent’s own text and tool rows only. The call that opened a sub-agent stays as an ordinary tool row, and the console says once that nothing draws sub-agents. Before, an AG-UI agent’s sub-agents streamed into the reply as if the agent had written it, and their tool calls were rows of the reply.
    • What the model reads. A sub-agent’s work is no longer part of the reply’s history, so it is not sent back to the model on the next turn.
    • AG-UI. @aparte/runner-ag-ui translates SUBAGENT_STARTED, SUBAGENT_FINISHED, SUBAGENT_ERROR and the subagentRunId on a sub-agent’s events: several sub-agents can stream at once, each keeps its own messages and calls, and an interrupt raised inside a sub-agent is asked about as that sub-agent’s. Most agent frameworks announce sub-agents only when asked to (LangGraph’s and Strands’ subagent_visibility="attributed", Mastra’s subagentVisibility: "attributed", ADK-JS’s subagents: "attributed"); the Sub-agents guide lists them.
    • Your own events. An event that carries an agentId, and agent-start / agent-end, never reach the reply, whatever drew them: a backend that writes the engine’s events as NDJSON for createAgentStreamRunner opens a sub-agent with agent-start, tags its events with its agentId, and closes it with agent-end. A run-start, run-done, run-aborted or run-suspended line that carries an agentId is dropped with a warning: a sub-agent never ends the run. @aparte/core, @aparte/runner-ag-ui
  • 570cdcc: A tool row can now say what its call is doing, on a line under its name, and add a note after its state: give the config a setToolLineProvider. On a narrow line the row’s parts now give way in a new order — the target first, then the note, the name last.

    ts
    import { aparteGlobalConfig } from "@aparte/core";
    
    aparteGlobalConfig.setToolLineProvider((segment) =>
      segment.toolCall.name === "delegate"
        ? { activity: "Reading parser.ts", note: "3 tools · 12s" }
        : undefined,
    );
    • The provider returns an AparteToolLine: label and target, used when your registerToolDisplay gives none; activity, a second line under the name, in every state you give it (give it for the call’s whole life, or never: a line that comes and goes moves every row under it); note, in every state; details, used when your display has no details key. Your display always wins, field by field. It is called at every draw, so its words follow a language switch. One per config; a chat with a config of its own reads the page’s when it has none. A row with no provider is drawn as before.
    • If you styled the row. What the call is doing is a new element, .aparte-tool-activity, placed last in the row’s line and on a line of its own: the row’s line now wraps for it, and for nothing else. Inside core’s row, .aparte-tool-label is display: contents, so the name and the target are laid out as parts of the line: a background, a border or a padding set on .aparte-tool-label there no longer draws — set it on .aparte-tool-name or .aparte-tool-target. The name, the target and the note now size with flex: <n> 1 0 and max-width: max-content; a flex-shrink of yours on them no longer decides who is cut first. A target the provider gives is words, .aparte-tool-target--words, in the chat’s own font.
    • For a plugin. createSegmentList holds a conversation that is not the reply — a stream adapter writes into it as into a chat, and each segment gets its index and timing (AparteSegmentList: segments, onChange). Feeding it events an observer handed you (a sub-agent’s)? Make that adapter with createStreamAdapter({ …, observe: false }), so the observers do not hear them a second time, unattributed. pluralize and formatDuration are exported, the plural and the duration a turn’s fold uses.
    • Fixed. A row’s details already in place are no longer rebuilt on every update of the call. @aparte/core
  • 570cdcc: A scripted turn can now delegate to scripted sub-agents: add a { subagents: [...] } step, and register the tool that runs them with scenarioSubagentTool(provider).

    ts
    import { aparteGlobalConfig } from "@aparte/core";
    import {
      createScenarioProvider,
      scenarioSubagentTool,
    } from "@aparte/provider-scenario";
    
    const provider = createScenarioProvider({
      turns: [
        [
          {
            subagents: [
              {
                name: "Reader",
                task: "Read the parser",
                turns: ["It splits on commas."],
              },
            ],
          },
        ],
        "The parser splits on commas.",
      ],
    });
    aparteGlobalConfig.registerAIProvider(provider);
    const { tool, handler } = scenarioSubagentTool(provider);
    aparteGlobalConfig.registerTool(tool, handler);

    The step makes the model call one ordinary tool, delegate, with { agents: [{ name, task }] }, as a real model would. Each ScenarioSubagent has a name, a task and the turns its own model plays; the handler runs each one through the real agent loop as a sub-agent, so its { tool } steps run your registered handlers, and several in one step run side by side. The model reads back each sub-agent’s last text; one that fails is said in a sentence and does not fail the call. toolName on the step and scenarioSubagentTool(provider, { name }) rename the tool; with scenarios, route the answer with after: 'delegate'. Add @aparte/plugin-subagents to see one line per sub-agent.

    A sub-agent’s turn can also be a function of the request its loop sends, (request) => turn, so a script can answer what its tool returned: a build runner that says so when its command was refused. @aparte/provider-scenario

  • 570cdcc: New @aparte/plugin-subagents: one line per sub-agent in the reply — its name, its task, what it is doing now, and “3 tools · 12s” — with its conversation under the line or in a pane of its own.

    bash
    npm install @aparte/plugin-subagents
    ts
    import { setupSubagents } from "@aparte/plugin-subagents";
    
    setupSubagents(); // the line alone
    setupSubagents({ details: "transcript" }); // the line opens on the sub-agent's conversation
    • The line. A sub-agent opened by a tool call is drawn on that call’s row, so registerToolDisplay for that tool still applies and wins (label, icon, summary, quiet, hidden, open, details). A sub-agent no call opened, or a second one opened by the same call, gets a line of its own, reached by the agent’s name. The line reads one of five states: Running, Waiting, Done, Failed, Stopped.
    • Options (SubagentsOptions): activity (a second line from its start to its end: Starting…, its latest tool call, then what it did — so the row keeps its height; on by default), counts (its tool calls and how long it worked, once it is over; on by default), details (false by default, 'transcript', or a function). subagentTranscript is the conversation as a details function, for one tool’s line.
    • Anywhere else. <aparte-subagent-view for="chat" message-id="…" agent-id="…"> shows a sub-agent’s conversation in a pane, a canvas or a dialog, live and after a reload. The chat dispatches aparte-subagent-start and aparte-subagent-end, which carry those ids.
    • Saved with the conversation. The sub-agent’s conversation is kept on the segment that stands for it and never sent to the model. subagentOf(segment) and subagentStatus(segment) read it back, in Node too; subagentStatus reads stopped for a sub-agent a reload or a Stop left unfinished.
    • The words are translated in the ten languages of @aparte/locales (subagentsTools, subagentsUnnamed, through extendLocale). @aparte/core is the only peer dependency.

    Guide: Sub-agents. @aparte/plugin-subagents

Patch Changes

  • d52cf1d: In a chat that centres its composer while empty, the first messages no longer go up and come back when a panel opens under the composer during the slide (an approval asked by the reply’s first call).

    The slide gives the transcript its room back over a few hundred milliseconds. A panel opening in that moment shrank the surface below the messages, the send’s glide (aimed a frame earlier at a reply bubble still counted at its placeholder height) scrolled into the gap, and the returning room brought the messages back down: 35 px up and back in 50 ms on the agent template. A transcript that will fit once that room is back now does not scroll, and gets no bottom spacer. @aparte/core

  • e037fb5: On a touch screen the chat no longer keeps 28 px at its end edge for the scroll rail, which is hidden there: the column is centred again on a phone.

    The rail hides under (pointer: coarse), since a 2 px tick is no target for a finger, and its lane stayed reserved. It now goes with it. On a screen with a mouse nothing changes: the lane is kept from the first message, so the column does not move when the rail appears. @aparte/core

  • 570cdcc: Resuming a paused reply no longer tells the model that a call still running, or still waiting for a person, was stopped: the call is left open for the agent to answer.

    When a reply paused while a call was not finished — the call that opened a sub-agent, whose sub-agent stopped for an approval — the request that resumed it answered that call with the stopped-tool text, so the model read that it never ran. It now sends that call unanswered, as it already did for the paused call itself. A server-loop resume is unchanged: every call there has settled, or carries its own ticket, by the time the run pauses. Nothing to change in your code. @aparte/core

Version-only bumps (no changes of their own): @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @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-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/docs-mcp.

1.7.0

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

Minor Changes

  • 88d71f3: An agent’s activity can now be drawn: register a renderer with config.registerActivityRenderer(type, renderer). AG-UI ACTIVITY_SNAPSHOT / ACTIVITY_DELTA are no longer dropped.

    ts
    const off = aparteGlobalConfig.registerActivityRenderer("search-progress", {
      render: (segment) => {
        const line = document.createElement("p");
        line.textContent = `${(segment.content as { read: number }).read} of 5 sources read`;
        return line;
      },
      update: (line, segment) => {
        line.textContent = `${(segment.content as { read: number }).read} of 5 sources read`;
      },
    });
    • @aparte/engine: a run event activity ({ id, activityType, content, agentId? }) in StreamRunEvent, and the same in a model call’s stream (StreamChatEvent), which the loop passes on; a sub-agent’s handle passes it on with its agentId. content is always the activity’s WHOLE current value: a consumer never applies a patch.
    • @aparte/core: a built-in segment type, AparteActivitySegment ({ type: 'activity', activityId, activityType, content }), placed in the reply where the activity first arrived and updated in place by every later event with the same id — never a second segment, a reply resumed after a pause included: its new run’s adapter finds the segment on the reply through the target’s getMessage (which the viewport and a wrapper’s host have) or, for a segment list, its segments — two new optional members of StreamAdapterTarget. The text it interrupts ends there and what follows is written after it, as around a tool call. It is drawn by the renderer registered for its type (registerActivityRenderer returns the function that takes it off; getActivityRenderer reads it); the renderer’s update patches the same element, and without update it is drawn again from render. With no renderer for its type it is kept on the message and draws nothing — an empty hidden element, no room, no orphan header — and a renderer registered later, or after a reload, draws it. It is saved with the message, never copied with the reply’s text, and never sent to the model: the wire history skips it by name. activity joins AparteStreamEventMap, so a provider can stream it. New types: AparteActivitySegment, AparteActivityRenderer.
    • @aparte/runner-ag-ui: ACTIVITY_SNAPSHOT becomes an activity with its content; ACTIVITY_DELTA is applied (RFC 6902, as STATE_DELTA is) to the content the runner holds for that message id, and the whole result is passed on. Per AG-UI 1.0, a snapshot with replace: false leaves an existing activity as it stands (content and type), and a delta for an activity no snapshot created is skipped with a warning, never failing the run; a patch that cannot apply leaves the activity as it was, with a warning. A sub-agent’s activity is attributed by its subagentRunId, and its delta stays its own. The conformance lane now asserts the two activity fixtures’ messages.
    • @aparte/provider-scenario: a script step { activity: { type, content, id? } }; the same id later updates it, in the same turn or a later one; in a scripted sub-agent it is the sub-agent’s.

    A sub-agent’s activity lands in its own conversation with no change to @aparte/plugin-subagents: drawn under its line (details: 'transcript') and in <aparte-subagent-view> by the same registered renderers. @aparte/core, @aparte/engine, @aparte/runner-ag-ui, @aparte/provider-scenario

  • 43db964: A step the agent announces now shows while it runs: the waiting indicator says it beside its dots, and a sub-agent’s line says its own. AG-UI STEP_STARTED / STEP_FINISHED are no longer dropped.

    ts
    // A sub-agent of your own loop announces one through its handle:
    agent.emit({ type: "step-start", name: "Reading the files" });
    agent.emit({ type: "step-end", name: "Reading the files" });
    // A scripted model:
    createScenarioProvider({
      turns: [
        [{ step: "Reading the parser" }, { tool: "read_file" }],
        [{ endStep: "Reading the parser" }, { text: "Done." }],
      ],
    });
    • @aparte/engine: two run events, step-start and step-end ({ name, agentId? }), in StreamRunEvent, and the same two in a model call’s stream (StreamChatEvent), which the loop passes on. A sub-agent’s handle passes them on with its agentId. Steps may nest and overlap; step-end ends the latest open step of its name.
    • @aparte/core: the stream adapter keeps the reply’s open steps and tells the chat through a new optional target method, setStep(messageId, name | null), only when the step to show changes, and with null when the run ends. The bubble’s setStep(name) writes it in a .aparte-waiting-step span beside the dots while the reply waits (nothing written yet, or a call done and the next not begun), and makes it the screen reader’s label in place of “Typing”, announced politely as it changes. The viewport and a wrapper’s host forward it; the host keeps it for a bubble the framework has not painted yet, so the wrappers need nothing. It is live only: never a segment, never saved, never sent to the model, and gone once the reply has text or ends. step-start / step-end join AparteStreamEventMap, so a provider can stream them.
    • @aparte/runner-ag-ui: STEP_STARTED / STEP_FINISHED become step-start / step-end, a sub-agent’s attributed by its subagentRunId. A step still open when its sub-agent ends, or when the run ends (finished, failed, refused or stopped), is closed then, so nothing is left lit.
    • @aparte/plugin-subagents: a sub-agent’s step is its line’s second line while none of its calls runs; a running call wins, and when the step ends the line says what it said before. Kept apart from the sub-agent’s saved conversation.
    • @aparte/provider-scenario: two script steps, { step } and { endStep }, in the same turn or across turns (a step can last across a tool call); in a scripted sub-agent the step is the sub-agent’s. @aparte/core, @aparte/engine, @aparte/runner-ag-ui, @aparte/provider-scenario, @aparte/plugin-subagents
  • e97381c: Menus and tabs drawn with the kit can now be driven from the keyboard: enhanceMenu, enhanceContextMenu and enhanceTabs.

    ts
    import { enhanceMenu, enhanceContextMenu, enhanceTabs } from "@aparte/core";
    
    const releaseMenu = enhanceMenu(button, menu, { align: "end" });
    menu.addEventListener("aparte-menu-select", (e) =>
      run(e.detail.item.dataset.action),
    );
    
    const releaseRowMenu = enhanceContextMenu(list, rowMenu, {
      onOpen: (target) => (target.closest("[data-id]") ? undefined : false),
    });
    
    const releaseTabs = enhanceTabs(tablist);
    tablist.addEventListener("aparte-tab-change", (e) =>
      console.log(e.detail.tab, e.detail.panel),
    );

    Each takes the kit’s existing markup (.aparte-menu with role="menuitem" items, .aparte-tabs with role="tab" and aria-controls) and returns a function that stops it. Nothing changes for markup drawn without them.

    • enhanceMenu(trigger, menu, options?) — the WAI-ARIA menu button. The button opens the menu on a click, Enter, Space, ArrowDown (first item) or ArrowUp (last item); inside, the arrows wrap, Home and End jump, a letter goes to the next item that starts with it, and disabled, aria-disabled or hidden items are skipped. Escape closes it and puts the focus back on the button; Tab closes it and moves on from the button; a press outside, the focus leaving or a resize close it, and so does a scroll that moves the button (the page, a list it is in) but not one beside it, such as a reply streaming in. A click on the button of an open menu closes it, WebKit included. One menu is open at a time. The menu is shown with hidden and placed fixed under the button with placeFloating (options: align, side, gap, margin, rtl). onOpen fills it as it opens (return false to keep it shut), onClose runs after.
    • enhanceContextMenu(region, menu, options?) — the same menu, opened by a right click (at the pointer), Shift+F10 or the Menu key (under the focused element) anywhere in region. onOpen(target) says which element it was asked about; return false to leave the browser its own menu. Escape puts the focus back where it was.
    • aparte-menu-select fires on the menu with { item } when an item is chosen, before it closes; preventDefault() keeps it open. A menuitemcheckbox or menuitemradio is not ticked for you: set aria-checked in the listener.
    • enhanceTabs(tablist, options?) — the WAI-ARIA tabs. One tab stop, ArrowRight / ArrowLeft (the other way round in right-to-left) or ArrowDown / ArrowUp with aria-orientation="vertical", Home and End, disabled and hidden tabs skipped; aria-selected kept, the panel named by aria-controls shown and the others hidden. activation: 'manual' lets the arrows move the focus only. aparte-tab-change fires on the tablist before a tab is selected, with { tab, panel, previous }; preventDefault() keeps the current one. Select from code with tab.click().
    • All three touch no DOM until called, so they are exported from the server entry too.

    The conversation list’s row menu now runs on them: it gains type-ahead, and a right click, Shift+F10 or the Menu key on a row opens the same menu there. Tab in the menu now moves on from the ⋯ button instead of stopping on it. The elicitation panel’s stepped questions and @aparte/plugin-artifacts’ card tabs run on enhanceTabs too; the card’s panes also carry hidden when they are not shown. @aparte/core, @aparte/plugin-artifacts

  • 735fa71: The tool calls of one model step now run at the same time; pass parallelTools: false to run them one after another.

    ts
    runStreamAgent({ ...options, parallelTools: false });
    // in a chat:
    new AparteClient({
      streamRunner: (opts) => runStreamAgent({ ...opts, parallelTools: false }),
    });

    Each call starts as soon as the model asks for it, and the rest of the reply keeps streaming while it runs; the model is called again once every call of the step has finished. Two tools that each run a sub-agent now run both sub-agents at once, their events interleaving under their own agentId.

    What does not depend on which call finishes first:

    • The history is in call order: the assistant message lists the calls as the model made them, and their tool results follow in that order. onHistoryAppend reports them in that order too, each once every call before it has finished.
    • A person is asked about one call at a time, in call order, sub-agents’ calls included; the calls that need no approval run meanwhile.
    • A refusal lets the calls already running finish. A call still waiting for its question is not run and is answered “Not run: an earlier call of the same step was refused.” (by: 'earlier-refusal'); the rest of the reply is not read, and the model then answers the refusal, as before.
    • A Stop, the turn limit, a call with no handler or no resolver, or a crash stops every call still running (tool-aborted, cause 'stopped'), then the run ends as before.
    • With deferral, a call that pauses does not stop the calls already running: the run is suspended once all of them have finished or paused, and run-suspended lists every paused call. A call the model makes after the pause waits, as before. If a call stops the run meanwhile (a timeout, no handler), the run ends as it does one call after another: the paused calls end as tool-aborted ('stopped'), and nothing is suspended.

    StreamToolRun gains parallelTools, so a sub-agent’s loop does as its run does. @aparte/core re-exports the option through AparteStreamRunOptions. @aparte/core, @aparte/engine

  • 504b70b: The plan card can be drawn from an agent’s activity: setupPlanCard({ activity: 'plan' }). A TanStack AI router’s plan now reaches the reply as a plan activity.

    ts
    import { setupPlanCard } from "@aparte/plugin-cards/plan";
    
    setupPlanCard({ activity: "plan" }); // AG-UI ACTIVITY_*, a sub-agent, a scenario
    setupPlanCard({ activity: ["plan", "todos"], tool: "update_plan" }); // both paths at once
    • @aparte/plugin-cards: every card’s setup takes activity (a type or a list of types), so any card can be driven by an activity. The activity’s content is read as the card’s data (for the plan card, every shape readPlan reads: Claude Code’s todos, Codex’s plan, a Markdown checklist…). Each new content patches the same card in place; content that holds nothing to draw yet draws nothing, and an update the card cannot read leaves the card it drew.
    • @aparte/runner-ag-ui: TanStack AI 1.0 puts its router’s plan on each direct child’s SUBAGENT_STARTED (metadata.tanstack.subagentPlan, { steps: [{ names, order? }] }), once. The runner now emits it as one plan activity of the reply (it is the parent’s plan of its sub-agents, not a sub-agent’s own): a step per agent in the router’s order, in progress when the agent starts, done, failed or blocked when it ends. Steps the router moved past read as done.
    • @aparte/plugin-subagents: a sub-agent’s conversation (under its line, in <aparte-subagent-view>) now follows activity and tool renderers registered after it was drawn, as a bubble does. Before, only a change of segment renderer redrew a row.
    • @aparte/core: onRenderersChange(listener) is exported, for a row loop written outside the bubble: it hears every segment, tool or activity renderer registered or taken off, once per config per microtask. @aparte/core, @aparte/runner-ag-ui, @aparte/plugin-cards, @aparte/plugin-subagents
  • b921d2e: A sub-agent’s line can open its conversation beside the chat: setupSubagents({ open: 'event' }) and connectSubagentView({ chat, view, split }). Without the option, nothing changes.

    ts
    import {
      connectSubagentView,
      setupSubagents,
    } from "@aparte/plugin-subagents";
    
    setupSubagents({ open: "event" });
    connectSubagentView({
      chat: document.getElementById("chat")!,
      view: document.querySelector("aparte-subagent-view")!,
      split: document.querySelector("aparte-split")!,
    });
    • @aparte/plugin-subagents: open: 'event' puts an Open button (core’s button recipe, named “Open Researcher” in the chat’s ten languages) at the end of each sub-agent’s line. Pressing it — click, Enter or Space — dispatches aparte-subagent-open (AparteSubagentOpenEventDetail: targetId?, messageId, agentId, name?, toolCallId?), bubbling and composed. A line with nothing behind it also opens on a click anywhere on it; with details too, the line keeps toggling its detail and only the button opens elsewhere, so one click never means two things. connectSubagentView points an <aparte-subagent-view> at the sub-agent, opens the split’s second pane (on a phone the split shows the view, then the chat again), marks the open line (data-current on the row, aria-current="true" on its button) and returns a function that undoes it all. Without a split, onOpen and onClose hand the layout to the app. A sub-agent’s own sub-agents, drawn as lines in the view, open in the same view.
    • <aparte-subagent-view closable>: the sub-agent’s name and a Close button above its conversation; Close, or Escape inside the view, dispatches aparte-subagent-view-close (the view does not hide itself). connectSubagentView sets it, folds the pane on it and puts the focus back on the line’s button. focusTitle() puts the focus on the name. A view opened while its sub-agent works now reads it from the plugin’s last write when the chat does not hold it yet (a framework that mirrors the messages a step behind).
    • @aparte/core: AparteToolLine.open (AparteToolLineOpen: label, onOpen(row), current?) — a tool-line provider can say a call can be shown elsewhere. Core draws the button at the end of the line, calls onOpen with the row, and keeps the button’s name and the current marks in step on update and relabel. On a row with a detail the button stays out of the <summary> (a control inside it is no control of its own): the row is then a div wrapping its <details class="aparte-tool-disclosure">, the button in an .aparte-tool-open-slot beside it, at the same place on the line. Without open, the row is unchanged. @aparte/core, @aparte/plugin-subagents
  • 5b6a286: A tool display’s details function now gets the element its row shows as a second argument: return it to keep it.

    ts
    aparteGlobalConfig.registerToolDisplay("edit_file", {
      details: (segment, held) => held ?? drawChange(segment),
    });

    held is the element the function returned for that row the last time it was asked, still in place behind the line; it is absent on a row’s first drawing. So a detail with state of its own (a fold opened, a comment half written) is kept through the call’s updates and a language switch without a cache in the app, and two rows drawing the same call (a reply and a pane beside it) never share one element. A function that ignores the argument behaves as before. @aparte/core

  • a815889: An n8n AI Agent Tool (a sub-agent) is now drawn as a sub-agent: its text goes on a line of its own, named after its node, and no longer into the reply. Add @aparte/plugin-subagents (setupSubagents()) to show the line; without it, that text is kept out of the reply and the console says so.

    • What n8n sends (recorded on n8n 2.47.7): an AI Agent Tool that streams sends frames under its own node, between its caller’s blocks. The caller’s block ends empty when its model asks for the tool, the sub-agent’s frames follow, then the caller streams again under the same node, run and item. Nothing else names the call. The runner reads exactly that: a stream that begins after an empty block is that agent’s sub-agent until the caller streams again, and it emits agent-start (named after the node, parentAgentId for a sub-agent’s sub-agent), the text with its agentId, and agent-end with the text as result. Only the caller streaming again proves it, so the line is drawn then, the sub-agent’s answer whole in it, not while it streams. A sub-agent called twice is two lines; a workflow that fails ends the open ones as failed.
    • What it cannot tell. An AI Agent Tool with Enable Streaming off sends no frame, so it shows nothing. A caller that writes text before its call looks like two agents in a row, and the sub-agent’s text is drawn in the reply as before. If the agent before it never streams again (two agents in a row, the first answering nothing), nothing was a sub-agent: what followed is the reply, drawn once, in order, with no line. @aparte/runner-n8n
  • 84ef498: New @aparte/plugin-diff: show a file change as hunks with line numbers, in the reply or beside it, and let the reader comment on a line.

    ts
    import { setupDiff } from "@aparte/plugin-diff";
    
    // An edit tool's result, as a diff under its line in the reply.
    setupDiff({
      tool: "edit_file",
      map: (result, input) => ({
        path: String(input.path),
        before: result.before,
        after: result.after,
      }),
    });
    
    // Beside the chat, open to comments.
    const view = document.querySelector("aparte-diff")!;
    view.commentable = true;
    view.diff = unifiedDiffText; // or { path, before, after }, or a list of files
    view.addEventListener("aparte-diff-comment", (e) => keep(e.detail)); // { path, side, startLine, endLine, text, code }
    view.comments = kept; // shown under their lines, pending or sent
    • <aparte-diff> shows each file under a header with its path, what happened to it (added, deleted, renamed) and its counts, which folds it; each line with its old and new numbers and a + or −, said as “added” and “removed” to a screen reader; the unchanged runs between hunks folded, with a “Show N unchanged lines” button when the whole text is known. The lines are coloured by the chat’s highlighter when one is installed, in the language of the path’s extension, and the code reads left to right in a right-to-left page.
    • Comments, with commentable: a click on a line number opens a field of the kit under the line, Shift+click stretches the selection; from the keyboard the numbers are one tab stop, the arrows move, Shift+arrows stretch, Enter or Space opens the field, Escape lets go. Sending fires aparte-diff-comment (bubbling, cancelable). The element keeps nothing: the comments the app hands back through comments are shown under their lines with their state. Without commentable, nothing is clickable.
    • setupDiff({ tool, map, commentable, open }, config?) puts the change behind an edit tool’s line, opened, and keeps the row’s label, summary and states. Each row has its own diff, kept through the call’s updates and gone with the row. It returns the function that takes it off.
    • diffTexts, parseUnifiedDiff, formatUnifiedDiff compute, read and write diffs with no DOM, from the server entry too. The line diff is Myers’ algorithm, written in the package: no dependency; a large file is first cut at the lines it holds once on each side (patience anchoring), so 200,000 lines changed in a thousand places still give a thousand small hunks in well under a second. A side given as null is a file created or deleted, '' an empty file. What formatUnifiedDiff writes, git apply takes (new file mode, deleted file mode, rename from / rename to); parseUnifiedDiff reads a rename only where git says one, so diff -u x.c.orig x.c is a change to x.c.
    • Tints are tokens that fall back to core’s (--aparte-diff-added-bg on --aparte-success-surface, --aparte-diff-removed-bg on --aparte-error-surface, and the inks); the words are in the ten languages @aparte/locales ships. @aparte/plugin-diff

Patch Changes

  • fe37513: A provider whose stream rejects when the run is stopped now ends the run as stopped (run-aborted, then run-done) instead of rejecting runStreamAgent. Nothing to change in your code.

    A provider reading a fetch on the run’s signal does not always close quietly on a Stop: the read the loop is parked on rejects, with an AbortError or whatever the cut socket says. The loop let that rejection out, so a deliberate Stop reached the caller as a failure, and a chat painted an error over the reply its reader had just stopped. It is decided by the signal now, as the run’s end already was: once it aborted, the run ends exactly as for a quiet close, a call still running told it was stopped. A provider that fails while nobody stopped the run still fails it. @aparte/engine

  • acdac24: A TanStack AI sub-agent that paused for an approval now resumes: the runner sends the sub-agents’ own messages back with the answer. Nothing to change in your code.

    • The resume carries the sub-agents’ messages. TanStack AI continues a paused sub-agent only from its own messages, found after the last user message, each tagged with its subagentRunId, with its card in metadata.tanstack.subagent (name, status, the interrupts it waits on, the router’s plan). The page’s history never holds a sub-agent’s words, so the resume carried none, and TanStack refused it: Resume entry references unknown interrupt. The runner now keeps what each sub-agent wrote and ran, hands it to the page in the pause’s ticket, and sends it after the history on the resume. A sibling that had finished is sent as finished, so TanStack does not run it again; the answer to a browser tool a sub-agent called goes with that sub-agent’s messages, after the one that declares the call. Only to TanStack AI (a run whose events carry metadata.tanstack): any other AG-UI agent keeps its sub-agents’ work itself, and its resume is unchanged. Verified against TanStack AI 1.0’s real chat(), with a router and with agent tools.
    • One plan card across a pause. The router’s plan used the run’s id, and a resumed run has a new one, so the resume drew a second card. The card’s id now comes with the ticket, and so does what it had ticked; the page’s resumed run updates the card in place (with @aparte/core of the same release, whose stream adapter finds an activity a paused run placed on the reply).
    • A run’s usage is its own when its sub-agents ran. TanStack AI puts the sub-agents’ model calls on the run’s RUN_FINISHED too, after the run’s own report, so the runner reported the last sub-agent call’s usage as the reply’s. It now reads the run’s own (the first entry), and none when the run’s own model never spoke (a router that only delegates). @aparte/runner-ag-ui
  • e5ca8cf: The summariser no longer reads an agent’s activity (an activity segment) as the reply’s text. Nothing to change in your code.

    An activity whose content was a string (a scenario’s, an app’s own) went into the transcript the summary is written from, under the rule for a segment type the plugin does not know (“its content”). The model never reads an activity back — core’s history serializer skips it by name — so the summariser, which reads what the model would have read, now skips it too. @aparte/plugin-compaction

Version-only bumps (no changes of their own): @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-transformers, @aparte/plugin-approval, @aparte/plugin-ask-user, @aparte/plugin-chartjs, @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/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/locales, @aparte/docs-mcp.

1.8.0

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

Minor Changes

  • b85cd5e: Tool calls run one after another again unless the tool says parallel: true; a call waiting for an approval holds the calls after it; createAparteAgentHandler and AparteClient take parallelTools.

    ts
    // A coding agent: reads run together, the edit and the command keep their order.
    aparteGlobalConfig.registerTool(
      { name: "read_file", description, inputSchema, parallel: true },
      readFile,
    );
    aparteGlobalConfig.registerTool(
      { name: "edit_file", description, inputSchema, needsApproval: true },
      editFile,
    );
    aparteGlobalConfig.registerTool(
      { name: "run_command", description, inputSchema },
      runCommand,
    );
    
    // A tool from an MCP server: it may run beside others when it says it only reads.
    const parallel = mcpTool.annotations?.readOnlyHint === true;
    
    // Every call one after another, `parallel` tools too:
    new AparteClient({ parallelTools: false });
    createAparteAgentHandler({ ...options, parallelTools: false });

    Do you have to touch your code?

    • If you relied on 1.7.0 running the calls of one reply at the same time: give those tools parallel: true (on AparteTool, on a server tool’s tool, or on StreamToolConfig for runStreamAgent).
    • If you time a call from its tool-start: tool-start now comes when the model writes the call, before it runs, so a call that waits its turn counts its time in the queue. A queued call (queued: true) runs from its tool-running.
    • If you switch exhaustively on StreamRunEvent['type'] (or AparteStreamRunEvent['type']): the new tool-running event needs a case.

    Fixes #202.

    Since 1.7.0 every call of one model step ran at the same time. For a coding agent that broke what the model meant: edit_file then run_command raced, and with an approval policy the command (allowed) ran while the person was still being asked about the edit, on the file as it was. A server loop could not opt out at all.

    • A call keeps its place by default. A call of a tool that says nothing starts once every call made before it in the same reply has settled, and the calls made after it start once it has: the order every tool had until 1.7.0, for anyone who does nothing. Calls of tools that say parallel: true run together, between the calls that keep their place. This is the rule coding agents follow — read-only tools together, writes and commands one at a time — and it maps onto MCP’s annotation: parallel: tool.annotations?.readOnlyHint === true.
    • A call waiting for an approval holds the calls after it, parallel ones included. While a call waits for a person’s answer (or the policy’s), the calls the model made after it in the step do not start; the calls made before it keep running. An approval lets them start; a refusal skips them all, each answered “Not run: an earlier call of the same step was refused.” (by: 'earlier-refusal'). This changes 1.7.0, where the calls that needed no approval ran meanwhile.
    • A call waiting its turn shows where the model wrote it, queued. Every call gets its tool-start as it is read, so its row stands before the text the model wrote after it. One that cannot run yet carries queued: true, and the new run event tool-running { toolCallId } says when it goes on (never sent for a call that went on at once). A queued call a refusal reaches is rejected as an earlier refusal; one a Stop reaches ends as tool-aborted ('stopped'). The server loop’s NDJSON carries both, and createAgentStreamRunner hands them on.
    • AparteToolCallSegment.queued (true, beside status: 'pending' — the status union is unchanged): the adapter sets it on a queued tool-start and removes it once the call goes on or ends. The row reads Queued (new locale key toolQueued, in all nine @aparte/locales bundles) with no spinner and no shimmer, its name in the muted ink, and the row carries data-queued. Live only: a restored conversation never keeps it. The turn summary names the step that runs, not one that waits, and so does a sub-agent’s line.
    • parallelTools keeps its meaning — run together the calls whose tools allow it, true by default — and false still runs every call one after another. createAparteAgentHandler and AparteClient now take it and pass it to the run, as they pass maxTurns.
    • parallel is new on AparteTool and on StreamToolConfig; AparteClient and createAparteAgentHandler hand a registered tool’s parallel to the loop, as they hand its needsApproval. A sub-agent’s run follows the same rule, through its run’s tool configs.
    • @aparte/provider-scenario’s scenarioSubagentTool says parallel: true, so two delegations of one reply still run side by side.

    What stays as in 1.7.0: the history is in call order, a person is asked about one call at a time, a Stop or the turn limit stops every call of the step, and with deferral a call that pauses does not stop the calls already running (the calls made after it are queued with the pause, and the resume runs them in order). @aparte/core, @aparte/engine, @aparte/provider-scenario, @aparte/plugin-subagents, @aparte/locales

Version-only bumps (no changes of their own): @aparte/runner-ag-ui, @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @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-titler, @aparte/plugin-triggers, @aparte/angular, @aparte/react, @aparte/svelte, @aparte/vue, @aparte/docs-mcp.

1.9.0

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

Minor Changes

  • dfa6f62: A busy .aparte-btn (aria-busy="true") now shows an .aparte-spinner child at its icon’s size and in its ink colour.

    html
    <button
      class="aparte-btn aparte-btn--primary aparte-btn--solid"
      type="button"
      aria-busy="true"
    >
      <span class="aparte-spinner" aria-hidden="true"></span>
      Loading…
    </button>

    Do you have to touch your code? No. A spinner you already put in a busy button keeps working: it is now drawn at the button’s icon size and in the button’s colour, whatever --sm or --lg it carries. A spinner anywhere else, in a button that is not aria-busy, or not a direct child of the button, is unchanged.

    • Colour. The ring was the spinner’s own muted grey on every fill. Measured against the fill in the light theme: 1.55:1 on a solid primary button, 1:1 on a solid neutral one (the ring was the fill’s own colour, so it was invisible), 1.49:1 on danger and 2.61:1 on warning. It is the button’s ink now, so it reads like the label does: 5.27, 5.5, 5.05 and 8.84:1. In the dark theme a solid primary ring went from 1.15:1 to 8.3:1. A disabled busy button keeps the recipe’s disabled look, and its ring is muted with it.
    • Size. The spinner takes --aparte-btn-icon-size, the size an icon gets in a button: 19.4px on the default button, 13px on --sm, 21.6px on --lg and --xl at the default type scale, where it was 16px on all of them. Replacing an icon with it no longer moves the button, which was 3 to 5.6px wider or narrower. The rule declares --aparte-spinner-size on the spinner, so .aparte-spinner--sm and --lg lose to it by selector, not by which sheet loads last; to size one yourself, set --aparte-spinner-size in its style.
    • Pointer. The spinner takes no pointer events, like an icon in a button, so a click on it is a click on the button.
    • As before. The cursor is progress, also on a disabled button. Reduced motion stops the ring, as it does every .aparte-spinner. aria-busy does not dim or disable the button: add disabled when a second click must do nothing.
    • Not done. The button keeps no width of its own: it follows its label, so a button that changes its label while busy (“Load model”, then “Loading…”) still resizes. Give it a minimum width. CSS cannot know the width of a label it has not been given.
    • Docs. The button page gains a Busy section with this markup, and an accessibility note: a screen reader often ignores aria-busy alone, so the label should say what is happening. @aparte/core
  • b2a427c: The chat’s imperative API gains getElement(), the chat’s root element, and getComposer(), its <aparte-composer>; every wrapper’s chat implements both.

    Do you have to touch your code? Only if a class of yours implements AparteChatImperativeApi: add getElement() and getComposer().

    • Why. An event core has no prop for — a plugin’s (aparte-subagent-open, aparte-artifact-open) or your own — reaches the chat’s root, because every part sends its events up to it. getElement() is that root, so each framework has one way to listen: useAparteEvent(chat.ref, …) in React, @aparte-… in Vue, onaparte-… in Svelte 5, (aparte-…) in Angular, getElement() in Svelte 4.
    • Same name as the proxy. AparteUiHandle already calls its accessor getElement(). @aparte/core
  • bec5c92: Links in a reply now open in a new tab, same-site ones included; setLinkTarget('external-only') keeps same-site links in the page.

    ts
    import { aparteGlobalConfig } from "@aparte/core";
    
    // As before: only a link to another site opens a new tab.
    aparteGlobalConfig.setLinkTarget("external-only");

    Do you have to touch your code? Only to keep a same-site link in the page. A relative link the model writes — [package.json](package.json), /docs — used to be followed in place, which replaces the page the chat lives in: in a single-page app or an Electron window, the whole app and the conversation with it. It now opens in a new tab, with rel="noopener noreferrer". To route a link yourself, cancel aparte-link-click, as before.

    • What stays as written. A link to a place in the page (#…), and mailto:, tel: and sms:, for which a new tab is left empty. A target the model writes still chooses nothing.
    • Whichever sanitizer. The rule runs in sanitizeHtml after the sanitizer, beside the image policy, so one set with setHtmlSanitizer keeps it — DOMPurify alone drops target, and every external link then navigated the chat’s own frame. Under 'external-only' the built-in sanitizer’s own clamp is applied on top of yours. A server render gets the same links.
    • Your rel is kept. A link that opens in a new tab keeps the rel tokens your sanitizer wrote (nofollow ugc) and gains noopener noreferrer; an opener token is dropped, as it would contradict noopener. A link that stays in the page keeps its rel untouched.
    • For a plugin that draws links, decideLink(href) answers what to set: { target: '_blank', rel: 'noopener noreferrer' }, or {} for a link that stays in the page. getLinkTarget() reads the mode, and setting it draws what is on screen again.
    • Sources. A source’s link in a citation card now fires the chat’s cancelable aparte-link-click, as a link in the text does: the card is drawn beside the transcript, outside the message, which never heard its clicks, so an app could not route it. It is announced on the chip, inside the message, with the same { href, anchor, messageId }. A source’s link, in the card or the list, follows the link target too.
    • Weight. About 1.7 KB gzip: the pass over a reply’s links, and its twin for a runtime with no DOM. With the rest of this release, core’s JavaScript is 269.4 KB gzip. @aparte/core
  • d1b38ad: Each turn now carries the id of the conversation open in the chat: conversationId on the run’s options, beside messageId, and createAgentStreamRunner takes an endpoint function that routes by it.

    ts
    createAgentStreamRunner({
      endpoint: ({ conversationId }) => `/api/agent/c/${conversationId}`,
    });

    Do you have to touch your code? No. A chat with no conversation sends nothing new, and a streamRunner that does not read the field behaves as before. Your server does receive a new field, conversationId in the body createAgentStreamRunner posts, whenever a conversation is open.

    • What it is. The conversation open in the chat when the person sent the message, read at that moment and not after the turn’s awaits (a key to resolve, a file to read), so a person who opens another conversation a moment later does not move the turn. The same on a retry, an edit, and the resume of a paused run, which goes out with the id of the run it continues. A first message carries the id of the conversation it creates. A chat with no conversation, no manager or none open, leaves the field out.
    • Route by it. endpoint is a string or a function of the run’s options, called for every request, so each conversation can have its own route. The runner also puts the id in the body, and AparteAgentRequestBody gains conversationId?.
    • On the server. createAparteAgentHandler gives a server tool the id as context.conversationId, beside context.request; a tool that runs in the page gets the same field in its context. A body whose conversationId is not a string is a 400, and an empty one is none. The id comes from the browser: it names a conversation and proves nothing about who owns it, so check it against the caller before opening a journal by it.
    • Where it is read. The conversation controller leaves a reader on the chat’s element, and AparteClient, which sits beside the chat, climbs to it. Every wrapper and the vanilla controller are covered, and no prop changed. A provider reads the request, which does not carry the id: only a runner gets it. A provider that wants it, to key a prompt cache, is the trigger to put it on the request as well. @aparte/core
  • 2e9e776: Show a step in the page’s language: config.registerStepLabel('reread', ({ locale }) => …) maps the key a server sends in step-start to the words the page shows.

    ts
    aparteGlobalConfig.registerStepLabel("slot-wait", "Waiting for a free slot…");
    aparteGlobalConfig.registerStepLabel("reread", ({ locale }) =>
      locale.tag?.startsWith("fr")
        ? "Relecture de la conversation…"
        : "Re-reading the conversation…",
    );

    Do you have to touch your code? No: a step nobody labelled is shown as its name, as before. If you rewrite every step-start name in a stream runner to reach the page’s language, you can stop: the name then stays the key in the run, for a screen reader’s text and for what you store.

    • Where it shows. The waiting indicator beside the dots, the words a screen reader hears in place of “Typing”, and a sub-agent’s line (@aparte/plugin-subagents reads the same label).
    • Live. A function label is asked again at every change of the locale, and registering a label, or taking it off with the function registerStepLabel returns, relabels a step that is already open.
    • Only what is shown is labelled. The step-start and step-end events, observeRunEvents, the target’s setStep and anything an app stores keep the key; a step was never saved with the reply.
    • Per config. One label per name, as the tool displays are: a chat with a config of its own reads that config’s labels, not the page’s. getStepLabel(name) answers what is registered for a name, or undefined.
    • Typed. AparteStepLabel and AparteStepLabelContext ({ name, locale }) are exported. No key is added to AparteLocale: the labels are the app’s. @aparte/core, @aparte/plugin-subagents
  • d9ca871: End-to-end tests have a stable contract: [data-aparte-chat], the field’s role and name, aparte-composer-send[data-act], [data-role], [aria-busy], [data-error-code] — see Testing your chat.

    Do you have to touch your code? Only if a CSS rule or a query of yours uses [data-aparte-chat] to mean the <div> a React, Vue or Svelte chat renders: it now matches <aparte-chat> and Angular’s host as well, so write div[data-aparte-chat] to keep the old meaning. Core’s own stylesheets name aparte-chat beside [data-aparte-chat] in every rule, so nothing in the chat restyles.

    • The root, in every framework. <aparte-chat> now carries data-aparte-chat when it connects, and Angular’s component declares it on its host, so the server render has it too. React, Vue and Svelte already rendered it on their root.
    • Send, Stop and Submit. <aparte-composer-send> says what a press does now, send, stop or submit, in data-act on itself. The button inside keeps its own data-act, which the stylesheet reads. Press the button: aparte-composer-send[data-act="stop"] button.
    • A reply that ended no longer says it is streaming. The viewport writes streaming on the bubble it appends for a reply on its way, and nothing took it off, so after a turn every reply of a vanilla chat still matched aparte-chat-bubble[streaming]. The bubble takes it off when the reply ends, however it ended: finished, failed or stopped. The reply’s aria-busy was always right; that is the hook for a test.
    • Frozen. data-aparte-chat and data-act are declared read-only on their elements, so the frozen surface lists them next to data-role, and removing one needs a notice release first. The field’s role and name, aria-busy and data-error-code sit on parts inside an element and are not on that list; a test plays a real turn and reads all three, and the guide’s Playwright example runs on the six example apps.
    • The field’s name. Its placeholder is its accessible name, so getByRole('textbox', { name }) finds it. getByPlaceholder does not, because the field has no placeholder attribute. The composer page and the input’s reference say so. @aparte/core, @aparte/angular
  • 893b450: StreamRunOptions gains conversationId, the id of the conversation the run belongs to, for a runner that sends the run elsewhere.

    Do you have to touch your code? No. The field is optional, and runStreamAgent does not read it: it is opaque to the loop, like messageId and providerId. AparteClient fills it from the conversation open in the chat when the person sent the message (see @aparte/core), and leaves it out when the chat has none.

    • Why here. A runner receives StreamRunOptions: createAgentStreamRunner routes by the id, createAgUiRunner runs the agent’s thread in it, and a runner of your own reads it as opts.conversationId. @aparte/engine
  • 2be85f4: An AG-UI turn now runs in the thread of its conversation: with no threadId given, the thread is the id of the conversation open in the chat, where it used to be a new one for every turn.

    ts
    // Before, by hand: threadId: () => manager.activeId. Now it is the default.
    createAgUiRunner({ endpoint: "/agui" });

    Do you have to touch your code? Only if you gave no threadId and your agent keeps state or history per thread. Each conversation is then one session on the agent, not one per turn: Agno’s session is now the conversation, and a history the agent stores for the thread arrives beside the whole history the runner still sends. A threadId you gave still decides, a chat with no conversation open still gets a new thread per turn, and a function that returns a new id each time gives the agent a new thread per turn, as before (it never sees a state or a cancelled interrupt again, since no thread comes back; the runner remembers the 64 most recently used threads, so such an app does not grow its memory):

    ts
    createAgUiRunner({
      endpoint: "/agui",
      threadId: () => `aparte-${crypto.randomUUID()}`,
    });
    • What the agent sees. The conversation’s id as threadId, where it saw a random one, on every turn of that conversation.
    • State. The state the agent last reported in a conversation is sent back as the next run’s state, as it already was for an app that named its thread. Another conversation starts from {}. The runner keeps the state of the 64 threads used most recently: past that, the oldest one starts from {} again.
    • Interrupts. One the page could not answer is cancelled on the conversation’s next run, as it already was for a named thread.
    • A pause still resumes in the thread it paused in, whatever the conversation says. @aparte/runner-ag-ui
  • 378700e: A link in the document <aparte-artifact-panel> shows now fires the chat’s cancelable aparte-link-click, so the listener that routes a reply’s links routes it too.

    • Why. The panel sits beside the chat, outside every message, so no message heard a click in it, and a same-site link in a document the model wrote replaced the page.
    • Where. On the chat the panel reads (for, chat, or the element an app’s handle names with getElement()), with { href, anchor, messageId }; a panel that names no chat sends it on itself. A link of yours in the header is yours, and is not announced. A panel placed inside a message (an app’s own renderer) stays quiet: the message announces it, once. Where the link opens follows the chat’s link target (setLinkTarget), as in the reply. @aparte/plugin-artifacts
  • 378700e: A link in a sub-agent’s conversation shown beside the chat (<aparte-subagent-view>) now fires the chat’s cancelable aparte-link-click, so the listener that routes a reply’s links routes it too.

    • Why. Beside the chat the view is outside every message, so no message heard a click in it, and a same-site link a sub-agent wrote replaced the page.
    • Where. On the chat the view reads (for, chat, or the element an app’s handle names with getElement()), with the reply’s messageId; a view that names no chat sends it on itself. A source the sub-agent cited goes to the chat the same way. Under a line, or anywhere else inside the reply (a view an app’s own renderer places in a message), the message announces it, once. Where the link opens follows the chat’s link target (setLinkTarget). @aparte/plugin-subagents
  • d4a7249: <aparte-chat> now has an output for every event of the chat — (linkClick), (retry), (feedback), (messageDone)… — each emitting the event’s detail; to cancel one, bind the DOM event itself on the same tag, (aparte-link-click).

    html
    <aparte-chat
      (linkClick)="open($event.href)"
      (aparte-link-click)="$event.preventDefault()"
    ></aparte-chat>

    Do you have to touch your code? No. (messageSent) and (action) keep their names and their payload.

    • Every event. The outputs come from a base class generated from the events <aparte-chat> declares, 23 today: the composer’s (messageSent, stop, composerChange, actionClick), the transcript’s and each message’s (pathChanged, retry, edit, feedback, linkClick…) and the turn’s (messageStart, messageDone, messageError…). An output is the event’s name without aparte-, in camelCase — save aparte-send, which is messageSent, and aparte-cancel, which is stop, since cancel is a DOM event and (cancel) would also catch every native one. An event the chat gains becomes an output with no change to this package.
    • Cancelling. The component’s host IS <aparte-chat>, so (aparte-link-click) on it binds the DOM event, and $event.preventDefault() keeps the browser from following the link. Both bindings run once per click.
    • Change detection. The listeners sit outside the zone, and an event enters it only for an output a template binds: aparte-segment-update comes once per streamed token and costs nothing unless you listen to it. Measured on the Angular example, a streamed chunk is on screen at a p95 of 17.9 to 19.4 ms over three runs, against 17.5 ms before the change, under a 50 ms budget.
    • Why. The component had two of the chat’s events as outputs.
    • Weight. 34.1 KB gzip, up 2.5 KB: the 23 outputs and the listener that feeds them. @aparte/angular
  • b2a427c: AparteChatComponent gains getElement(), the host <aparte-chat>, and getComposer(), its <aparte-composer>.

    html
    <aparte-chat (aparte-subagent-open)="openPanel($event.detail)"></aparte-chat>

    Do you have to touch your code? No. A plugin’s event is already a native (aparte-…) binding on the tag, since the host IS the core element; a test pins that it fires once, beside (linkClick). @aparte/angular

  • 4b8cfa4: On the aparte-composer directive, bind (stop) instead of (cancel): (cancel) also caught a file input’s native cancel event.

    html
    <aparte-composer (send)="send($event)" (stop)="stopped()"></aparte-composer>

    Do you have to touch your code? Yes, if a template binds (cancel) on <aparte-composer>: rename it to (stop). Left as it is, it still compiles, because Angular reads it as a DOM listener, but it no longer runs when Stop is pressed, only when a native cancel bubbles out of the composer.

    In an Angular template, (x) listens to the DOM event x and subscribes to the output x. The Stop output was named cancel, a DOM event that bubbles: a file input fires it when its picker closes with no file chosen, so (cancel) ran for the Stop button and for every such picker inside the composer. The generated directives now refuse an output named like a DOM event, the names read from TypeScript’s own DOM typings, and no other output was one.

    The directives’ output names were not yet on What will not change under you, which is why this one could move without a notice release. @aparte/angular

  • d4a7249: <AparteChat> now takes a callback for every event of the chat — onLinkClick, onRetry, onFeedback, onMessageDone… — and each callback receives the event after its detail, so event.preventDefault() works.

    tsx
    <AparteChat
      onLinkClick={(detail, event) => {
        event.preventDefault();
        navigate(detail.href);
      }}
    />

    Do you have to touch your code? No. onMessageSent and onAction keep their names, and their first argument is still the detail: a callback written for it alone still fits.

    • Every event. The props are generated from the events <aparte-chat> declares, 23 today: the composer’s (onMessageSent, onStop, onComposerChange, onActionClick), the transcript’s and each message’s (onPathChanged, onRetry, onEdit, onFeedback, onLinkClick…) and the turn’s (onMessageStart, onMessageDone, onMessageError…). A prop is the event’s name without aparte-, in camelCase, after on — save aparte-send, which is onMessageSent, and aparte-cancel, which is onStop. An event the chat gains becomes a prop with no change to this package.
    • Cancelling. aparte-link-click is cancelable: event.preventDefault() in onLinkClick keeps the browser from following the link, so the app can route it itself.
    • Why. The component exposed two of the chat’s events; the rest could only be reached through a DOM listener on its root, and preventDefault() through none of its props.
    • Weight. 5.2 KB gzip, up 0.5 KB: the table of the 23 events the component listens for. @aparte/react
  • df764c4: Every element of core now has a React component — <AparteConversationList>, <AparteLauncher>, <AparteSplit>… — with its properties as props and its events as onXxx callbacks, the same under React 18 and 19.

    tsx
    <AparteConversationList
      conversations={history.activeConversations}
      active-id={history.activeId}
      onConversationDelete={(detail) => void history.delete(detail.id)}
    />

    Do you have to touch your code? No. The raw tags keep working, typed as they were. Two typing changes can show an error in code that was already wrong: Vue now checks a multi-word attribute (:active-id="5" passed unchecked, because Vue looks a kebab-case attribute up by its camelCase name) and types the events a tag sends, and every attribute now accepts null to remove it, in React, Vue and Svelte, so active-id={history.activeId}, a string | null, compiles as written.

    • 24 components. One per element but the chat, whose component stays <AparteChat>, named Aparte and the tag in Pascal case, each with an Aparte…Props type. Generated from the manifest like the Angular directives: an element, an attribute or an event added to core reaches React with no edit. A table of them is in the wrapper reference.
    • A callback is (detail, event), as <AparteChat>’s are: the detail first, so a handler written for it alone still fits, and the event second, where event.preventDefault() is. The conversation list’s rename, pin, archive and delete are cancelable, and manage stands down when one is cancelled. A callback that changes takes no new listener.
    • Why not the raw tag. React 18 writes a property as the text [object Object] and listens to no event; React 19 sets a prop as a property when the element has one of that name and as an attribute when it does not. A component writes its props itself after the render — attributes through applyElementProps, properties by assignment, events with addEventListener — and only the ones whose value changed. A presence attribute takes a boolean there (flat, manage={false}), where the raw tag has to write ''.
    • Server rendering. An element carries defer-hydration until React has hydrated it, as <AparteChat>’s root does, and an attribute an element reads once, at connect (framework-managed on the viewport), is in its first markup, not applied after.
    • Vue and Svelte. Both already set a property an element has and listen to its events at runtime (a test mounts the raw list in each); what they lacked was the types. A property such as the list’s conversations is now typed in both, and Vue declares each tag’s events as emits, from a file generated from the manifest (--element-members). A presence attribute written bare in a Vue template, <aparte-select searchable>, is accepted as it is, and false is not. @aparte/core widens AparteAttrValue to accept null.
    • Weight. @aparte/react goes from 5.4 KB to 7.3 KB gzip (+1.9 KB): a table row for each of the 24 components, and the one function behind them. An app pays for the ones it imports, and <AparteChat> is one of them: its definition has no side effect, so useAparteEvent alone bundles to 0.6 KB gzip and <AparteConversationList> alone to 1.1 KB (esbuild over the published file). A bundle of <AparteConversationList> alone holds one createAparteElement call and none of the other 23 components’ names, and a bundle of all of them holds 24 (esbuild, sideEffects: false and a /* @__PURE__ */ on each). The package’s budget in size-budget.json rises from 5.5 to 7.75 KB. @aparte/core, @aparte/react, @aparte/svelte, @aparte/vue
  • b2a427c: New useAparteEvent(ref, type, handler) listens to an event <AparteChat> has no prop for — a plugin’s aparte-subagent-open, or your own — and the chat’s ref now has getElement() and getComposer().

    tsx
    const chat = useAparteChat();
    useAparteEvent(chat.ref, "aparte-subagent-open", (event) =>
      openPanel(event.detail),
    );

    Do you have to touch your code? No. UseAparteChat now extends AparteChatImperativeApi, so it carries every method of it, these two included.

    • Typed. The event is typed by HTMLElementEventMap, which every plugin package augments: event.detail needs no cast.
    • No resubscribe. The latest handler is called; a new function takes no new subscription. It unsubscribes on unmount.
    • Where to call it. In the component that renders the chat, so the ref is set when its effect runs. The target can also be an element. @aparte/react
  • d4a7249: <AparteChat> now sends every event of the chat — on:linkClick on the Svelte 4 component, onlinkClick on the runes one (@aparte/svelte/runes), and the same for retry, feedback, messageDone… — and preventDefault() on a cancelable one reaches the chat.

    svelte
    <!-- @aparte/svelte/runes -->
    <AparteChat onlinkClick={(detail, event) => { event.preventDefault(); goto(detail.href); }} />
    
    <!-- @aparte/svelte -->
    <AparteChat on:linkClick={(event) => { event.preventDefault(); goto(event.detail.href); }} />

    Do you have to touch your code? No. messageSent and action keep their names on both components, as events and as the callback props onmessageSent and onaction, whose first argument is still the detail: a callback written for it alone still fits.

    • Every event. The events are generated from the ones <aparte-chat> declares, 23 today: the composer’s (messageSent, stop, composerChange, actionClick), the transcript’s and each message’s (pathChanged, retry, edit, feedback, linkClick…) and the turn’s (messageStart, messageDone, messageError…). A name is the event’s without aparte-, in camelCase — save aparte-send, which is messageSent, and aparte-cancel, which is stop. An event the chat gains reaches both components with no change to this package.
    • The runes component takes a callback prop for each — on and the name, as Svelte spells it — called with the detail, then the DOM event.
    • The Svelte 4 component dispatches a component event for each, the detail under event.detail. preventDefault() on it cancels the chat’s event: aparte-link-click is cancelable, and cancelled it keeps the browser from following the link. onmessageSent and onaction stay, and now also receive the DOM event as their second argument.
    • Why. Both components exposed two of the chat’s events; the rest could only be reached through a DOM listener on their root. @aparte/svelte
  • b2a427c: Both <AparteChat> components expose getElement() and getComposer(), and the Svelte 5 one sets any onaparte-* attribute on its root, so a plugin’s event is onaparte-subagent-open={…}.

    svelte
    <AparteChat onaparte-subagent-open={(event) => openPanel(event.detail)} />

    Do you have to touch your code? No. AparteChatStore (createAparteChat()) now extends AparteChatImperativeApi, so it carries every method of it.

    • Svelte 5. What the component does not declare is spread on its root element, the chat’s own callbacks excepted. The onaparte-* attributes are typed by HTMLElementEventMap, with an open onaparte-${string} for the rest.
    • Svelte 4. bind:this the chat, then getElement()?.addEventListener(…) in onMount. @aparte/svelte
  • d4a7249: <AparteChat> now emits every event of the chat — @link-click, @retry, @feedback, @message-done… — and each listener receives the event after its detail, so event.preventDefault() works.

    vue
    <AparteChat
      @link-click="
        (detail, event) => {
          event.preventDefault();
          router.push(detail.href);
        }
      "
    />

    Do you have to touch your code? No. @message-sent and @action keep their names, and their first argument is still the detail: a listener written for it alone still fits.

    • Every event. The emits are generated from the events <aparte-chat> declares, 23 today: the composer’s (@message-sent, @stop, @composer-change, @action-click), the transcript’s and each message’s (@path-changed, @retry, @edit, @feedback, @link-click…) and the turn’s (@message-start, @message-done, @message-error…). An emit is the event’s name without aparte- — save aparte-send, which is messageSent, and aparte-cancel, which is stop. An event the chat gains becomes an emit with no change to this package.
    • Cancelling. aparte-link-click is cancelable: event.preventDefault() in @link-click keeps the browser from following the link, so the app can route it itself.
    • Why. The component emitted two of the chat’s events; a listener for any other fell through to its root div as a DOM listener under the wrong name, and heard nothing.
    • Weight. 5.7 KB gzip, up 0.5 KB: the table of the 23 events the component listens for. @aparte/vue
  • b2a427c: <AparteChat> exposes getElement() and getComposer(), and @aparte-some-event on it hears a plugin’s event; useAparteChat() returns both too.

    vue
    <AparteChat @aparte-subagent-open="openPanel($event.detail)" />

    Do you have to touch your code? No. useAparteChat’s return type is now the exported UseAparteChat, which extends AparteChatImperativeApi.

    • How. An event the chat does not declare as an emit falls through to its root element, where every event of the chat arrives; a test pins it. @aparte/vue

Patch Changes

  • 76a073e: <aparte-chat> lists, in the shipped custom-elements manifest and on its reference page, the 23 events a listener on it hears, each with its detail type.

    Do you have to touch your code? No: nothing dispatches differently. The events reached the chat before; the manifest now says which, so an editor’s tooltip and the element’s page show them, and the wrapper bindings can be generated from them.

    • What is listed. What the chat’s parts send, bubbling — the composer’s (aparte-send, aparte-cancel, aparte-composer-change, and aparte-action-click from a composer button the app wrote), the transcript’s (aparte-segment-update, aparte-path-changed, aparte-reset-done), each message’s (aparte-action, aparte-retry, aparte-edit, aparte-feedback, aparte-feedback-reason, aparte-message-info, aparte-link-click, aparte-attachment-preview) — and what the host that drives the chat sends on it: the turn (aparte-message-start, -done, -error, -aborted, -paused, -resumed, aparte-tool-approval-request) and aparte-conversation-loaded. Each description is written for a listener on the chat.
    • What is not, and why. The page-wide events go out on window (aparte-abort, aparte-compact, aparte-config-change, …) and no listener on the chat hears them. Three reach the chat and stay off its list: aparte-branch-navigate, which the viewport stops and answers with aparte-path-changed; aparte-composer-submit, the bubble’s inline editor’s Enter, which the bubble turns into aparte-edit; and aparte-tab-change, a stepped elicitation moving between its questions.
    • Kept true. The list is checked against the source in both directions: an event a part starts sending that the chat does not declare, or a declared one nothing sends, fails the build. @aparte/core
  • e443f95: hidden now hides a kit element whatever whitespace separates its classes, and hidden="until-found" keeps its find-in-page reveal.

    html
    <!-- The newline before the kit's class used to leave this footer painted. -->
    <footer
      class="my-footer
      aparte-card__footer"
      hidden
    >
      …
    </footer>

    Do you have to touch your code? No. An element that carries hidden and a kit class is now hidden in the cases below, where it used to stay visible. One that carries hidden="until-found" is no longer forced to display: none: see the second point.

    • Any whitespace. HTML separates class names with any ASCII whitespace: space, tab, line feed, form feed, carriage return. The kit’s rule knew only the space, so hidden did nothing on an element whose kit class came after a tab or a newline (a multi-line className template string in JSX writes one), or started a value that began with one: class="my-footer\naparte-card__footer" hidden kept the display: flex of .aparte-card__footer. Measured in Chromium on the published stylesheet: a tab and a line feed gave flex before; the tab, the line feed, the form feed and the carriage return, in either position, give none now.
    • hidden="until-found". The kit forced display: none on it, which defeats the browser’s find-in-page: the browser hides that state with content-visibility: hidden, so that a match inside can reveal it. The kit now leaves it alone, and the element keeps its own box while its content is hidden, as any element with that state does: a .aparte-card__footer measured 17px (its padding and its border), where it was 0. An engine that does not know until-found reads it as plain hidden, whose display: none the recipe’s display outranks, so there such an element is shown. Only an element you wrote until-found on is concerned.
    • Still the kit’s classes only. No bare [hidden]: a host element is untouched, and so is a class that merely contains the prefix (my-aparte-card).
    • Tests. The stylesheet test reads what the selectors mean, decoding their CSS escapes: a tab needle written \9aparte- would be U+009A followed by parte-, because a is a hex digit, and fails there as it does in a browser. A Playwright spec builds the elements on the published stylesheet and reads what the engine paints. @aparte/core
  • 378700e: An item of the items card that links to mailto: or tel: opens the mail or phone app, not an empty new tab.

    • The item’s link asks the chat’s link target (config.decideLink), as a link in a reply does: a web page opens in a new tab, and says so to a screen reader; a mailto: or tel: link gets no target, and no “opens in a new tab”. @aparte/plugin-cards
  • 378700e: A streamed link opens where the chat’s link target says: in a new tab by default, same-site ones included, as in the finished reply.

    • The plugin asks config.decideLink(href) instead of keeping its own copy of core’s external-link rule, so a link gets the same target and rel from the chunk its address arrives in to the settled reply, under setLinkTarget('external-only') too, and with the config the chat was set up with. @aparte/plugin-streaming-markdown
  • 76a073e: The <aparte-context> directive no longer has a (compact) output: it never fired. The gauge sends aparte-compact on window, so listen there.

    ts
    window.addEventListener("aparte-compact", (event) =>
      console.log(event.detail.targetId),
    );

    Do you have to touch your code? Only if a template binds (compact) on <aparte-context>: that handler never ran, and still compiles (Angular reads it as a DOM listener). Move it to a window listener as above.

    The generated directives give no Output to an event the element sends on window, because a listener on the element can never hear it. The list of those events was kept by hand and had fallen behind the gauge’s Retry, which sends aparte-compact when no compactor is registered. It is checked against the source now, both ways, so a window-only event cannot become an Output again — and an event the element sends on itself cannot lose one. @aparte/angular

Version-only bumps (no changes of their own): @aparte/runner-n8n, @aparte/provider-ai-sdk, @aparte/provider-openai-compat, @aparte/provider-scenario, @aparte/provider-transformers, @aparte/plugin-approval, @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-titler, @aparte/plugin-triggers, @aparte/locales, @aparte/docs-mcp.

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.