@syntrologie/adapt-chatbot 2.8.0-canary.292 → 2.8.0-canary.293

package/dist/AdaptiveChatBar.js

@@ -1,8 +1,8 @@
 import {
   AdaptiveChatBar
 } from "./chunk-SCVTTLFJ.js";
-import "./chunk-4P74RX6V.js";
-import "./chunk-UC4XU6GH.js";
+import "./chunk-YQU3O7VK.js";
+import "./chunk-C6K7W3LO.js";
 import "./chunk-UVKRO5ER.js";
 export {
   AdaptiveChatBar

package/dist/AdaptiveChatTrail.js

@@ -1,7 +1,7 @@
 import {
   AdaptiveChatTrail
-} from "./chunk-4P74RX6V.js";
-import "./chunk-UC4XU6GH.js";
+} from "./chunk-YQU3O7VK.js";
+import "./chunk-C6K7W3LO.js";
 import "./chunk-UVKRO5ER.js";
 export {
   AdaptiveChatTrail

package/dist/ChatAssistantLit.js

@@ -1,8 +1,8 @@
 import {
   ChatAssistantLitMountable,
   renderFallbackHtml
-} from "./chunk-IQKCST6R.js";
-import "./chunk-UC4XU6GH.js";
+} from "./chunk-FLSMUFFX.js";
+import "./chunk-C6K7W3LO.js";
 import "./chunk-VLJ3WOEX.js";
 import "./chunk-UVKRO5ER.js";
 export {

package/dist/{chunk-UC4XU6GH.js → chunk-C6K7W3LO.js}

@@ -223,8 +223,8 @@ var _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes
   const policyName = "dompurify" + (suffix ? "#" + suffix : "");
   try {
     return trustedTypes.createPolicy(policyName, {
-      createHTML(html8) {
-        return html8;
+      createHTML(html9) {
+        return html9;
       },
       createScriptURL(scriptUrl) {
         return scriptUrl;
@@ -2238,6 +2238,7 @@ var en = x.lex;
 import { html as html22 } from "lit";
 import { html as html3, nothing as nothing2 } from "lit";
 import { html as html5 } from "lit";
+import { html as html8, LitElement as LitElement2 } from "lit";
 var sendIcon = html2`<svg width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M8 14V2M8 2L3 7M8 2L13 7" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
 var stopIcon = html2`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><rect x="1" y="1" width="12" height="12" rx="2" fill="currentColor"/></svg>`;
 function autoResize(e) {
@@ -2369,18 +2370,20 @@ function renderBubbleContent(message) {
   return html4`<div data-sc-msg-assistant>${unsafeHTML(renderMarkdown(message.content))}</div>`;
 }
 function renderMessageBubble(props) {
-  const { message, toolLabels, toolRenderers, defaultToolRenderer } = props;
+  const { message, toolLabels, toolRenderers, toolContext, defaultToolRenderer } = props;
   const isUser = message.role === "user";
   const toolCards = message.toolCalls?.map((tc) => {
-    const approve = () => props.onToolApprove(tc.id);
+    const approve = (payload) => props.onToolApprove(tc.id, payload);
     const deny = () => props.onToolDeny(tc.id);
+    const context = toolContext?.[tc.name];
     const customRenderer = toolRenderers?.[tc.name];
     if (customRenderer) {
       return customRenderer.render({
         toolCall: tc,
         phase: tc.status,
         approve,
-        deny
+        deny,
+        context
       });
     }
     if (defaultToolRenderer) {
@@ -2388,13 +2391,14 @@ function renderMessageBubble(props) {
         toolCall: tc,
         phase: tc.status,
         approve,
-        deny
+        deny,
+        context
       });
     }
     return renderToolCallCard({
       toolCall: tc,
       toolLabel: toolLabels?.[tc.name],
-      approve,
+      approve: () => approve(),
       deny
     });
   });
@@ -2435,11 +2439,12 @@ function renderMessageList(props) {
     props.messages,
     (msg) => msg.id,
     (msg) => guard(
-      [fingerprint(msg)],
+      [fingerprint(msg), props.toolContext],
       () => renderMessageBubble({
         message: msg,
         toolLabels: props.toolLabels,
         toolRenderers: props.toolRenderers,
+        toolContext: props.toolContext,
         defaultToolRenderer: props.defaultToolRenderer,
         onCopy: props.onCopy,
         onRegenerate: props.onRegenerate,
@@ -2990,6 +2995,19 @@ var SyntroChat = class extends LitElement {
           if (event.isTyping) this._scrollToBottom();
           break;
         case "tool-call": {
+          const hasParent = this._messages.some((m2) => m2.id === event.messageId);
+          if (!hasParent) {
+            this._messages = [
+              ...this._messages,
+              {
+                id: event.messageId,
+                role: "assistant",
+                content: "",
+                timestamp: Date.now(),
+                status: "streaming"
+              }
+            ];
+          }
           this._messages = this._messages.map((m2) => {
             if (m2.id !== event.messageId) return m2;
             const existing = (m2.toolCalls ?? []).findIndex((tc) => tc.id === event.toolCall.id);
@@ -3038,6 +3056,50 @@ var SyntroChat = class extends LitElement {
           });
           break;
         }
+        case "tool-call-deferred": {
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map(
+              (tc) => tc.id === event.toolCallId ? { ...tc, interruptId: event.interruptId, status: "pending" } : tc
+            );
+            return { ...m2, toolCalls };
+          });
+          break;
+        }
+        case "tool-call-cancelled": {
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map(
+              (tc) => tc.id === event.toolCallId ? { ...tc, status: "cancelled" } : tc
+            );
+            return { ...m2, toolCalls };
+          });
+          break;
+        }
+        case "tool-call-result": {
+          let foundToolName;
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map((tc) => {
+              if (tc.id !== event.toolCallId) return tc;
+              foundToolName = tc.name;
+              return { ...tc, result: event.result, status: "done" };
+            });
+            return { ...m2, toolCalls };
+          });
+          this.dispatchEvent(
+            new CustomEvent("tool-result-received", {
+              detail: {
+                toolCallId: event.toolCallId,
+                toolName: foundToolName,
+                result: event.result
+              },
+              bubbles: true,
+              composed: true
+            })
+          );
+          break;
+        }
         case "error":
           this._errorMessage = event.message;
           break;
@@ -3074,16 +3136,45 @@ var SyntroChat = class extends LitElement {
     this._onRegenerate = (messageId) => {
       this.transport.send({ type: "regenerate", messageId });
     };
-    this._onToolApprove = (toolCallId) => {
+    this._onToolApprove = (toolCallId, payload, _retryCount = 0) => {
+      const interruptId = this._findInterruptId(toolCallId);
+      if (interruptId) {
+        this._markToolDone(toolCallId);
+        this.transport.send({
+          type: "deferred-tool-resume",
+          interruptId,
+          decision: "approve",
+          ...payload?.editedArgs ? { editedArgs: payload.editedArgs } : {}
+        });
+        return;
+      }
+      if (_retryCount < 10) {
+        setTimeout(() => this._onToolApprove(toolCallId, payload, _retryCount + 1), 200);
+        return;
+      }
       this._markToolDone(toolCallId);
       this.transport.send({
         type: "tool-result",
         toolCallId,
-        result: null,
+        result: payload?.editedArgs ?? null,
         approved: true
       });
     };
-    this._onToolDeny = (toolCallId) => {
+    this._onToolDeny = (toolCallId, _retryCount = 0) => {
+      const interruptId = this._findInterruptId(toolCallId);
+      if (interruptId) {
+        this._markToolDone(toolCallId);
+        this.transport.send({
+          type: "deferred-tool-resume",
+          interruptId,
+          decision: "deny"
+        });
+        return;
+      }
+      if (_retryCount < 10) {
+        setTimeout(() => this._onToolDeny(toolCallId, _retryCount + 1), 200);
+        return;
+      }
       this._markToolDone(toolCallId);
       this.transport.send({
         type: "tool-result",
@@ -3102,6 +3193,47 @@ var SyntroChat = class extends LitElement {
       this.sendUserMessage(text2);
     };
   }
+  // ── Public API: thread navigation ──────────────────────────────────
+  //
+  // Composing elements (the per-surface wrappers like
+  // <ap-action-plan-chat>) call these to load past threads and start
+  // new ones. The chat element doesn't own the thread index — that's
+  // the consumer's job (typically a sibling <syntro-chat-thread-list>
+  // + the consumer's REST endpoint). This element just owns the
+  // visible message state.
+  /**
+   * Replace the chat's message history wholesale. Used by the host
+   * shell when switching threads (after fetching the new thread's
+   * messages from persistence) or when restoring a session.
+   *
+   * Emits `chat-messages-replaced` so dependent UI (overlay cards,
+   * action plan sidebar) can react.
+   */
+  replaceMessages(messages) {
+    this._messages = [...messages];
+    this._isStreaming = messages.some((m2) => m2.status === "streaming");
+    this._userScrolledUp = false;
+    requestAnimationFrame(() => this._scrollToBottom());
+    this.dispatchEvent(
+      new CustomEvent("chat-messages-replaced", {
+        detail: { messageCount: messages.length },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  /**
+   * Clear the chat for a fresh conversation. Equivalent to
+   * `replaceMessages([])` plus a state reset.
+   */
+  reset() {
+    this._messages = [];
+    this._isStreaming = false;
+    this._isTyping = false;
+    this._inputValue = "";
+    this._userScrolledUp = false;
+    this._errorMessage = null;
+  }
   createRenderRoot() {
     return this;
   }
@@ -3198,6 +3330,13 @@ var SyntroChat = class extends LitElement {
     this._messages = [...this._messages, msg];
     this._scrollToBottom();
   }
+  _findInterruptId(toolCallId) {
+    for (const m2 of this._messages) {
+      const tc = m2.toolCalls?.find((t) => t.id === toolCallId);
+      if (tc?.interruptId) return tc.interruptId;
+    }
+    return void 0;
+  }
   _markToolDone(toolCallId) {
     this._messages = this._messages.map((m2) => {
       if (!m2.toolCalls) return m2;
@@ -3237,6 +3376,7 @@ var SyntroChat = class extends LitElement {
       isTyping: this._isTyping,
       toolLabels: this.toolLabels,
       toolRenderers: this.toolRenderers,
+      toolContext: this.toolContext,
       defaultToolRenderer: this.defaultToolRenderer,
       onCopy: this._onCopy,
       onRegenerate: this._onRegenerate,
@@ -3277,6 +3417,7 @@ SyntroChat.properties = {
   suggestions: { attribute: false },
   toolLabels: { attribute: false },
   toolRenderers: { attribute: false },
+  toolContext: { attribute: false },
   defaultToolRenderer: { attribute: false },
   autoExecTools: { attribute: false },
   placeholder: { type: String },
@@ -3291,6 +3432,117 @@ SyntroChat.properties = {
   _userScrolledUp: { state: true },
   _errorMessage: { state: true }
 };
+var SyntroChatThreadList = class extends LitElement2 {
+  constructor() {
+    super(...arguments);
+    this.threadsEndpoint = "";
+    this.activeThreadId = null;
+    this.newThreadLabel = "New thread";
+    this.emptyStateLabel = "No threads yet";
+    this._threads = [];
+    this._loading = false;
+    this._error = null;
+    this._onThreadClick = (threadId) => {
+      if (threadId === this.activeThreadId) return;
+      this.dispatchEvent(
+        new CustomEvent("thread-selected", {
+          detail: { threadId },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.threadsEndpoint) void this.refresh();
+  }
+  updated(changed) {
+    if (changed.has("threadsEndpoint") && this.threadsEndpoint) {
+      void this.refresh();
+    }
+  }
+  /** Re-fetch the thread index. Call after creating/archiving a thread. */
+  async refresh() {
+    if (!this.threadsEndpoint) return;
+    this._loading = true;
+    this._error = null;
+    try {
+      const res = await fetch(this.threadsEndpoint, {
+        method: "GET",
+        headers: { ...this.authHeaders ?? {}, Accept: "application/json" }
+      });
+      if (!res.ok) {
+        this._error = `Failed to load threads (${res.status})`;
+        this._threads = [];
+        return;
+      }
+      const data = await res.json();
+      this._threads = (data.threads ?? []).filter((t) => t.status !== "archived");
+    } catch (e) {
+      this._error = e instanceof Error ? e.message : "Failed to load threads";
+      this._threads = [];
+    } finally {
+      this._loading = false;
+    }
+  }
+  /** Imperative: request the host to start a new thread.
+   *  Fires `new-thread-requested`. The host clears the chat element and
+   *  drops `activeThreadId` so the next user message goes to a fresh
+   *  backend thread.
+   */
+  createNewThread() {
+    this.dispatchEvent(new CustomEvent("new-thread-requested", { bubbles: true, composed: true }));
+  }
+  render() {
+    return html8`
+      <div data-sc-thread-list>
+        <button
+          type="button"
+          data-sc-new-thread-btn
+          @click=${() => this.createNewThread()}
+          aria-label=${this.newThreadLabel}
+        >
+          ${this.newThreadLabel}
+        </button>
+        ${this._loading ? html8`<div data-sc-thread-list-loading>Loading…</div>` : this._error ? html8`<div data-sc-thread-list-error>${this._error}</div>` : this._threads.length === 0 ? html8`<div data-sc-thread-list-empty>${this.emptyStateLabel}</div>` : html8`<ul data-sc-thread-list-items role="list">
+                  ${this._threads.map(
+      (t) => html8`
+                      <li
+                        data-sc-thread-list-item
+                        ?data-sc-active=${t.remoteId === this.activeThreadId}
+                      >
+                        <button
+                          type="button"
+                          @click=${() => this._onThreadClick(t.remoteId)}
+                          title=${t.title ?? t.remoteId}
+                        >
+                          ${t.title || "Untitled thread"}
+                        </button>
+                      </li>
+                    `
+    )}
+                </ul>`}
+      </div>
+    `;
+  }
+};
+SyntroChatThreadList.properties = {
+  threadsEndpoint: { type: String, attribute: "threads-endpoint" },
+  authHeaders: { attribute: false },
+  activeThreadId: { type: String, attribute: "active-thread-id" },
+  newThreadLabel: { type: String, attribute: "new-thread-label" },
+  emptyStateLabel: { type: String, attribute: "empty-state-label" },
+  _threads: { state: true },
+  _loading: { state: true },
+  _error: { state: true }
+};
+if (!customElements.get("syntro-chat-thread-list")) {
+  customElements.define("syntro-chat-thread-list", SyntroChatThreadList);
+}
 if (!customElements.get("syntro-chat")) {
   customElements.define("syntro-chat", SyntroChat);
 }
@@ -3303,4 +3555,4 @@ export {
 dompurify/dist/purify.es.mjs:
   (*! @license DOMPurify 3.3.1 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.1/LICENSE *)
 */
-//# sourceMappingURL=chunk-UC4XU6GH.js.map
+//# sourceMappingURL=chunk-C6K7W3LO.js.map