@aparte/core 0.16.8 → 0.16.10

package/dist/{dialog-triggers-D8wNICrT.js → dialog-triggers-cYGTlfZf.js}

@@ -3151,9 +3151,24 @@ class AparteConversationManager {
   _listeners = /* @__PURE__ */ new Set();
   _initialized = false;
   _retention = null;
+  _titleProvider = null;
   constructor(adapter, options) {
     this._adapter = adapter;
     this._retention = options?.retention ?? null;
+    this._titleProvider = options?.titleProvider ?? null;
+  }
+  // ─── Title provider ─────────────────────────────────────────────────────
+  /**
+   * Replace how a new conversation is titled from its first user message.
+   * `null` restores the default (the message's text). The provider is consulted
+   * once per conversation, on that first message; `updateTitle` is untouched.
+   */
+  setTitleProvider(provider) {
+    this._titleProvider = provider;
+  }
+  /** The registered title provider, or `null` when the default applies. */
+  getTitleProvider() {
+    return this._titleProvider;
   }
   // ─── Initialisation ────────────────────────────────────────────────────
   /** Load all conversations from the adapter. Call once at app startup. */
@@ -3229,7 +3244,7 @@ class AparteConversationManager {
       ...conv,
       messages: [...conv.messages, msg],
       updatedAt: Date.now(),
-      title: isFirstUserMsg ? this._autoTitle(msg) : conv.title
+      title: isFirstUserMsg ? await this._title(msg) : conv.title
     };
     this._replace(updated);
     await this._adapter.save(updated);
@@ -3362,10 +3377,23 @@ class AparteConversationManager {
       }
     });
   }
+  /**
+   * The title of a conversation, decided once, on its first user message: the
+   * provider's answer when one is registered and answers, else the default.
+   */
+  async _title(msg) {
+    const fallback = this._autoTitle(msg);
+    if (!this._titleProvider) return fallback;
+    try {
+      const title = (await this._titleProvider((msg.content ?? "").trim(), msg)).trim();
+      return title || fallback;
+    } catch (err) {
+      console.warn("[AparteConversationManager] the title provider threw; the default title stands:", err);
+      return fallback;
+    }
+  }
   _autoTitle(msg) {
-    const raw = msg.content;
-    const text = typeof raw === "string" ? raw : (raw ?? "").toString();
-    return text.trim() || "New Chat";
+    return (msg.content ?? "").trim() || "New Chat";
   }
 }
 function filesToAttachments(files) {
@@ -4385,13 +4413,13 @@ class AparteChatHost {
     });
   }
 }
-function dispatchLifecycleEvent(target, name, detail) {
-  const id = target.id || void 0;
+function dispatchLifecycleEvent(target, name, detail, targetId) {
+  const id = targetId ?? (target.id || void 0);
   const stamped = detail && typeof detail === "object" ? { targetId: id, ...detail } : detail;
   target.dispatchEvent(new CustomEvent(name, { bubbles: true, composed: true, detail: stamped }));
 }
 function createStreamAdapter(opts) {
-  const { target, config, messageId } = opts;
+  const { target, config, messageId, targetId } = opts;
   let parser = new AparteStreamParser({ blocks: config.getStreamBlocks() });
   let streaming = /* @__PURE__ */ new Set();
   let thinkingId = null;
@@ -4479,7 +4507,7 @@ function createStreamAdapter(opts) {
       }
       case "tool-awaiting-approval":
         target.updateSegment?.(`tool-${e.toolCallId}`, { status: "awaiting-approval" });
-        dispatchLifecycleEvent(target, "aparte-tool-approval-request", { toolCallId: e.toolCallId, toolName: e.name, input: e.input });
+        dispatchLifecycleEvent(target, "aparte-tool-approval-request", { toolCallId: e.toolCallId, toolName: e.name, input: e.input }, targetId);
         break;
       case "tool-approved":
         target.updateSegment?.(`tool-${e.toolCallId}`, { status: "pending" });
@@ -4513,7 +4541,7 @@ function createStreamAdapter(opts) {
         }
         break;
       case "run-aborted":
-        dispatchLifecycleEvent(target, "aparte-message-aborted", { messageId });
+        dispatchLifecycleEvent(target, "aparte-message-aborted", { messageId }, targetId);
         break;
       case "run-done":
         target.updateMessage?.(messageId, { status: "completed" });
@@ -4690,12 +4718,20 @@ function buildEnumField(field, onChange, fallbackLabel, settle) {
   wrap.appendChild(list);
   const controls = () => Array.from(list.querySelectorAll(".aparte-elic-control"));
   const other = () => list.querySelector('input[value="__other__"]');
+  let arrowed = false;
+  list.addEventListener("keydown", (e) => {
+    arrowed = e.key.startsWith("Arrow");
+  });
+  list.addEventListener("click", () => {
+    arrowed = false;
+  });
   list.addEventListener("change", () => {
     const o = other();
     if (o && otherText) {
       otherText.style.display = o.checked ? "" : "none";
-      if (o.checked) otherText.focus();
+      if (o.checked && !arrowed) otherText.focus();
     }
+    arrowed = false;
     onChange();
   });
   otherText?.addEventListener("input", onChange);
@@ -5313,6 +5349,7 @@ class AparteClient {
    * sequence, so it can't drift between the three entry points.
    */
   async _streamTurn(targetElement, messageId, provider, messages, modelId, authConfig, opts) {
+    const chatId = this._targetIdOf(targetElement);
     const registeredTools = this._toolsForCurrentModel();
     let baseRequest = {
       messages,
@@ -5328,22 +5365,22 @@ class AparteClient {
       baseRequest = { ...baseRequest, tools: void 0 };
     }
     if (this._isAborted) {
-      dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId });
+      dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
       this._updateMessage(targetElement, messageId, { status: "completed" });
       return;
     }
-    dispatchLifecycleEvent(targetElement, "aparte-message-start", { messageId, role: "assistant" });
+    dispatchLifecycleEvent(targetElement, "aparte-message-start", { messageId, role: "assistant" }, chatId);
     const streamController = new AbortController();
     try {
       const usage = await this._streamLoop(targetElement, messageId, provider, baseRequest, authConfig, streamController);
       if (this._isAborted || streamController.signal.aborted) {
         this._updateMessage(targetElement, messageId, { status: "completed" });
       } else {
-        dispatchLifecycleEvent(targetElement, "aparte-message-done", { messageId, role: "assistant", usage });
+        dispatchLifecycleEvent(targetElement, "aparte-message-done", { messageId, role: "assistant", usage }, chatId);
       }
     } catch (error) {
       if (this._isAborted || streamController.signal.aborted) {
-        dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId });
+        dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
         this._updateMessage(targetElement, messageId, { status: "completed" });
         return;
       }
@@ -5531,13 +5568,64 @@ class AparteClient {
     return null;
   }
   /**
-   * Convert AparteMessage[] to AparteChatMessage[] for re-submission.
+   * Which chat a render target BELONGS to — the id the lifecycle events must carry.
+   *
+   * Not `target.id`: the target is whatever renders, and an `<aparte-chat>` shell
+   * delegates that to its `.viewport`, which has no id. So every lifecycle event on
+   * a shell-shaped chat went out unstamped, and the receive side reads a missing id
+   * as "for every chat on the page" — deliberately, so a single-chat page needs no
+   * wiring. On a two-chat page one chat's turn therefore drove every composer.
+   *
+   * The climb is the same rule `aparte-composer._ownTargetId` uses on the receive
+   * side, and it has to be, or the two would disagree about which chat is which:
+   * the nearest `aparte-chat` / `[data-aparte-chat]` ancestor (or the element
+   * itself) that HAS an id. Deliberately not `chatBoundaryOf` — that returns the
+   * boundary whether or not it is identified, and an id-less boundary must fall
+   * through to the next one up rather than answer "no id".
+   */
+  _targetIdOf(el2) {
+    let node = el2 ?? null;
+    while (node) {
+      const tag = node.tagName?.toLowerCase();
+      const isHost = tag === "aparte-chat" || node.hasAttribute?.("data-aparte-chat");
+      if (isHost && node.id) return node.id;
+      node = node.parentElement;
+    }
+    return el2?.id || void 0;
+  }
+  /**
+   * Convert AparteMessage[] to AparteChatMessage[] for re-submission (retry, edit).
+   *
+   * The SLICE is each caller's own business — retry cuts before the reply it is
+   * regenerating, edit cuts after the message being reworded, send cuts at the last
+   * answered turn. What a message CONTRIBUTES to the wire is not: send, retry and
+   * edit must not disagree about it, and they did. This one had no filter at all,
+   * so a failed turn and a turn stopped before its first token both went out as
+   * `{ role: 'assistant', content: '' }` — a claim the assistant said nothing, which
+   * some providers reject outright and the rest read as an empty reply worth
+   * imitating.
    */
   _messagesToChatMessages(messages) {
-    return messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
+    return this._wireHistory(messages);
+  }
+  /**
+   * The one rule for what a message contributes to the wire.
+   *
+   * Not the slice — the contribution: a role the wire has (`user`/`assistant`), a
+   * turn that neither failed nor is still in flight, and text that is not empty.
+   *
+   * `_wireText` (not `m.content`): assistant replies stream their text into
+   * `segments`, leaving `content` as '', so without flattening every reply would be
+   * empty here and the drop below would swallow the whole transcript.
+   */
+  _wireHistory(messages) {
+    return messages.filter((m) => {
+      if (m.role !== "user" && m.role !== "assistant") return false;
+      return m.status !== "error" && !AparteClient._inFlight(m);
+    }).map((m) => ({
       role: m.role,
       content: this._wireText(m)
-    }));
+    })).filter((m) => m.content.length > 0);
   }
   /** The "no model selected" warning is said once per client, not once per dropped send. */
   _warnedNoModel = false;
@@ -5671,22 +5759,30 @@ class AparteClient {
     messages.push({ role: "user", content: userMsg });
     return messages;
   }
+  /**
+   * A turn that has not finished yet. `status` is OPTIONAL on `AparteMessage`, so
+   * the question the history gates can ask is "is this still in flight?", never
+   * "is this completed?".
+   *
+   * The gates below used to ask the second one, and a host that SEEDS a transcript
+   * — restoring a saved conversation, hydrating a server-rendered one — has no
+   * reason to invent a status for turns that are already over. With none, the
+   * cutoff never advanced past 0 and the whole transcript was sliced away: the
+   * model got the new question with no context, and nothing in the UI said so,
+   * because the viewport still showed every message.
+   */
+  static _inFlight(m) {
+    return m.status === "streaming" || m.status === "pending";
+  }
   _toHistoryMessages(messages) {
     let cutoff = 0;
     for (let i = 0; i < messages.length; i++) {
       const m = messages[i];
-      if (m.role === "assistant" && m.status === "completed") {
+      if (m.role === "assistant" && m.status !== "error" && !AparteClient._inFlight(m)) {
         cutoff = i + 1;
       }
     }
-    return messages.slice(0, cutoff).filter((m) => {
-      if (m.role === "user") return m.status !== "error";
-      if (m.role === "assistant") return m.status === "completed";
-      return false;
-    }).map((m) => ({
-      role: m.role,
-      content: this._wireText(m)
-    })).filter((m) => m.content.length > 0);
+    return this._wireHistory(messages.slice(0, cutoff));
   }
   /**
    * A message's text as the MODEL should read it — the one mapper both history
@@ -5859,10 +5955,12 @@ ${content}
    */
   async _runViaStreamRunner(streamRunner, targetElement, messageId, provider, baseRequest, authConfig, streamController) {
     const signal = streamController.signal;
+    const chatId = this._targetIdOf(targetElement);
     const adapter = createStreamAdapter({
       target: targetElement,
       config: this._config,
-      messageId
+      messageId,
+      ...chatId ? { targetId: chatId } : {}
     });
     const prefixSegments = baseRequest._meta?.["prefixSegments"];
     const emitter = (event) => {
@@ -5955,7 +6053,7 @@ ${content}
         segments: [errorSegment]
       });
     }
-    dispatchLifecycleEvent(target, "aparte-message-error", { messageId, error });
+    dispatchLifecycleEvent(target, "aparte-message-error", { messageId, error }, this._targetIdOf(target));
   }
 }
 function findHead(node) {
@@ -6269,7 +6367,7 @@ function applyElementProps(el2, props, transformValue = (value) => value) {
       if (value === null || value === void 0) el2.style.removeProperty(key);
       else if (typeof value === "object" || typeof value === "function") el2.style.removeProperty(key);
       else el2.style.setProperty(key, String(value));
-    } else if (key.startsWith("on")) {
+    } else if (key.toLowerCase().startsWith("on")) {
       el2.removeAttribute(key);
     } else if (value === null || value === void 0 || value === false) {
       el2.removeAttribute(key);
@@ -6407,4 +6505,4 @@ export {
   collectRendererStyles as y,
   contentToText as z
 };
-//# sourceMappingURL=dialog-triggers-D8wNICrT.js.map
+//# sourceMappingURL=dialog-triggers-cYGTlfZf.js.map