@tylertech/forge-ai 0.15.2 → 0.15.3-dev.1

package/dist/ai-chatbot/message-state-controller.mjs

@@ -1,4 +1,14 @@
 import { generateId } from "./utils.mjs";
+function withoutMcpAppResource(toolCall) {
+  if (!toolCall.uiResource && !toolCall.uiResourceStatus) {
+    return toolCall;
+  }
+  const { uiResource: _uiResource, uiResourceStatus: _uiResourceStatus, ...rest } = toolCall;
+  return rest;
+}
+function responseItemWithoutMcpAppResource(item) {
+  return item.type === "toolCall" ? { type: "toolCall", data: withoutMcpAppResource(item.data) } : item;
+}
 class MessageStateController {
   constructor(_host, _config) {
     this._host = _host;
@@ -103,33 +113,61 @@ class MessageStateController {
     this.#updateResponseInItems();
     this.#notifyStateChange();
   }
+  /**
+   * Applies `updates` to a tool call wherever it is rendered: the in-progress response,
+   * an already finalized/restored response, or a top-level tool-call item.
+   */
   updateToolCallInResponse(toolCallId, updates) {
     const toolCall = this._toolCalls.get(toolCallId);
     if (!toolCall) {
       return;
     }
-    const isCompleting = updates.status === "complete" || updates.status === "error";
+    const isFinishing = updates.status === "complete" || updates.status === "error" || updates.status === "cancelled";
     const updated = {
       ...toolCall,
       ...updates,
-      ...isCompleting && !toolCall.endTimestamp ? { endTimestamp: Date.now() } : {}
+      ...isFinishing && !toolCall.endTimestamp ? { endTimestamp: Date.now() } : {}
     };
     this._toolCalls.set(toolCallId, updated);
-    if (this._activeResponse) {
-      for (const child of this._activeResponse.children) {
-        if (child.type === "toolCall" && child.data.id === toolCallId) {
-          child.data = updated;
-          break;
-        }
-      }
-    }
-    this.#updateResponseInItems();
+    this.#replaceToolCall(updated);
     this.#notifyStateChange();
   }
   completeToolCallInResponse(toolCallId, result, event) {
     this.updateToolCallInResponse(toolCallId, {
       result,
-      status: event?.isError === true ? "error" : "complete"
+      status: this.#resultStatus(event),
+      ...event ? {
+        structuredContent: event.structuredContent,
+        structuredContentOmitted: event.structuredContentOmitted,
+        mcpResult: event.mcpResult,
+        mcpResultOmitted: event.mcpResultOmitted
+      } : {}
+    });
+  }
+  #resultStatus(event) {
+    if (event?.cancelled) {
+      return "cancelled";
+    }
+    return event?.isError ? "error" : "complete";
+  }
+  #replaceToolCall(updated) {
+    const matches = (child) => child.type === "toolCall" && child.data.id === updated.id;
+    const replace = (children) => children.map((child) => matches(child) ? { type: "toolCall", data: updated } : child);
+    const activeResponse = this._activeResponse;
+    if (activeResponse?.children.some(matches)) {
+      activeResponse.children = replace(activeResponse.children);
+    }
+    this._messageItems = this._messageItems.map((item) => {
+      if (item.type === "toolCall" && item.data.id === updated.id) {
+        return { type: "toolCall", data: updated };
+      }
+      if (item.type !== "assistant" || !item.data.children.some(matches)) {
+        return item;
+      }
+      if (item.data.id === activeResponse?.id) {
+        return { type: "assistant", data: { ...activeResponse } };
+      }
+      return { type: "assistant", data: { ...item.data, children: replace(item.data.children) } };
     });
   }
   tryFinalizeResponse() {
@@ -242,14 +280,32 @@ class MessageStateController {
     this.#notifyStateChange();
     this._config.onThreadSettled?.();
   }
+  /** Tool call ids rendered at or after `index`, inside assistant responses or as top-level items. */
+  getToolCallIdsFrom(index) {
+    return this._messageItems.slice(index).flatMap((item) => {
+      if (item.type === "toolCall") {
+        return [item.data.id];
+      }
+      if (item.type === "assistant") {
+        return item.data.children.flatMap((child) => child.type === "toolCall" ? [child.data.id] : []);
+      }
+      return [];
+    });
+  }
+  /** Removes items from `index` onward and returns the ids of the tool calls they held. */
   removeMessageItemsFrom(index) {
+    const removedToolCallIds = this.getToolCallIdsFrom(index);
+    removedToolCallIds.forEach((id) => this._toolCalls.delete(id));
     this._messageItems = this._messageItems.slice(0, index);
     this._activeResponse = null;
     this.#notifyStateChange();
+    return removedToolCallIds;
   }
   /**
    * Reconstructs the message hierarchy for API compatibility.
    * Converts assistant responses back to ChatMessage format with tool calls.
+   * MCP-app `uiResource`/`uiResourceStatus` are stripped: resources are re-resolved via the
+   * adapter on restore, never persisted or sent back to the agent.
    */
   getMessages() {
     const messages = [];
@@ -258,8 +314,9 @@ class MessageStateController {
         messages.push({ ...item.data, toolCalls: [] });
       } else if (item.type === "assistant") {
         const response = item.data;
-        const textContent = response.children.filter((c) => c.type === "text").map((c) => c.content).join("");
-        const toolCalls = response.children.filter((c) => c.type === "toolCall").map((c) => c.data);
+        const children = response.children.map(responseItemWithoutMcpAppResource);
+        const textContent = children.filter((c) => c.type === "text").map((c) => c.content).join("");
+        const toolCalls = children.filter((c) => c.type === "toolCall").map((c) => c.data);
         const message = {
           id: response.id,
           role: "assistant",
@@ -268,13 +325,13 @@ class MessageStateController {
           status: response.status === "streaming" ? "streaming" : response.status === "error" ? "error" : "complete",
           toolCalls: toolCalls.length ? toolCalls : void 0,
           feedback: response.feedback,
-          children: response.children
+          children
         };
         messages.push(message);
       } else if (item.type === "toolCall") {
         const lastMsg = messages[messages.length - 1];
         if (lastMsg && lastMsg.role === "assistant") {
-          lastMsg.toolCalls = [...lastMsg.toolCalls || [], item.data];
+          lastMsg.toolCalls = [...lastMsg.toolCalls || [], withoutMcpAppResource(item.data)];
         }
       }
     }
@@ -289,10 +346,11 @@ class MessageStateController {
         let children;
         if (msg.children?.length) {
           children = msg.children.map((child) => {
-            if (child.type === "toolCall") {
-              this._toolCalls.set(child.data.id, child.data);
+            const restored = responseItemWithoutMcpAppResource(child);
+            if (restored.type === "toolCall") {
+              this._toolCalls.set(restored.data.id, restored.data);
             }
-            return child;
+            return restored;
           });
         } else {
           children = [];
@@ -300,7 +358,7 @@ class MessageStateController {
             children.push({ type: "text", messageId: msg.id, content: msg.content, status: "complete" });
           }
           if (msg.toolCalls) {
-            for (const toolCall of msg.toolCalls) {
+            for (const toolCall of msg.toolCalls.map(withoutMcpAppResource)) {
               children.push({ type: "toolCall", data: toolCall });
               this._toolCalls.set(toolCall.id, toolCall);
             }

package/dist/ai-chatbot/tool-canvas.d.ts

@@ -0,0 +1,60 @@
+import { ToolCall, ToolCanvas, ToolCanvasInline, AnyToolDefinition, ToolPresentation } from './types.js';
+export interface ForgeAiCanvasOpenRequestEventData {
+    toolCallId: string;
+    toolName: string;
+    title?: string;
+    /** Set to true by the host once the tool call is showing in the canvas. */
+    handled?: boolean;
+}
+export interface ForgeAiCanvasCloseRequestEventData {
+    toolCallId: string;
+    /** Set to true by the host once the canvas has closed. */
+    handled?: boolean;
+}
+declare global {
+    interface HTMLElementEventMap {
+        'forge-ai-canvas-open-request': CustomEvent<ForgeAiCanvasOpenRequestEventData>;
+        'forge-ai-canvas-close-request': CustomEvent<ForgeAiCanvasCloseRequestEventData>;
+    }
+}
+/** State a canvas host shares with the tool calls rendered in its thread. */
+export interface ToolCanvasHostState {
+    /** Presentation assigned to inline renderers of canvas-enabled tools. */
+    presentation: ToolPresentation;
+    /** Tool call currently shown in the canvas, if any. */
+    openToolCallId?: string;
+}
+/**
+ * Provided by hosts that render tool calls next to a canvas panel. Without a provider, inline
+ * renderers get `inline`.
+ */
+export declare const toolCanvasHostContext: {
+    __context__: ToolCanvasHostState;
+};
+/**
+ * Asks the nearest canvas host to show the given tool call. Hosts without a canvas leave the event
+ * unhandled. Returns whether the tool call is now showing.
+ */
+export declare function requestCanvasOpen(target: EventTarget, detail: ForgeAiCanvasOpenRequestEventData): boolean;
+/** Asks the nearest canvas host to close the canvas if it is showing the given tool call. Returns whether it closed. */
+export declare function requestCanvasClose(target: EventTarget, detail: ForgeAiCanvasCloseRequestEventData): boolean;
+export interface CreateToolCanvasConfig {
+    available: boolean;
+    /** Read live by `toggle()`; `isOpen` on the result is a snapshot taken when the controls are built. */
+    isOpen: () => boolean;
+    open: (options?: {
+        title?: string;
+    }) => boolean;
+    close: () => boolean;
+}
+/** Builds the `canvas` controls a host injects into a tool renderer. */
+export declare function createToolCanvas({ available, isOpen, open, close }: CreateToolCanvasConfig): ToolCanvas;
+export declare function resolveToolCanvasTitle(toolCall: ToolCall, toolDefinition: AnyToolDefinition): string;
+export declare function resolveToolCanvasSubtitle(toolCall: ToolCall, toolDefinition: AnyToolDefinition): string | undefined;
+export declare function resolveToolCanvasActionLabel(toolCall: ToolCall, toolDefinition: AnyToolDefinition, active: boolean): string;
+/**
+ * Resolves the artifact card icon to a fresh `<svg>` element, or undefined for the card's default glyph.
+ * Markup strings are parsed and reduced to an allowlist of shape elements and presentation attributes.
+ */
+export declare function resolveToolCanvasIcon(toolCall: ToolCall, toolDefinition: AnyToolDefinition): SVGElement | undefined;
+export declare function resolveToolCanvasInline(toolDefinition: AnyToolDefinition): ToolCanvasInline;

package/dist/ai-chatbot/tool-canvas.mjs

@@ -0,0 +1,128 @@
+import { createContext } from "@lit/context";
+const toolCanvasHostContext = createContext(/* @__PURE__ */ Symbol("forge-ai-tool-canvas-host"));
+function requestCanvasOpen(target, detail) {
+  const request = { ...detail, handled: false };
+  target.dispatchEvent(
+    new CustomEvent("forge-ai-canvas-open-request", {
+      detail: request,
+      bubbles: true,
+      composed: true
+    })
+  );
+  return request.handled;
+}
+function requestCanvasClose(target, detail) {
+  const request = { ...detail, handled: false };
+  target.dispatchEvent(
+    new CustomEvent("forge-ai-canvas-close-request", {
+      detail: request,
+      bubbles: true,
+      composed: true
+    })
+  );
+  return request.handled;
+}
+function createToolCanvas({ available, isOpen, open, close }) {
+  return {
+    available,
+    isOpen: isOpen(),
+    open: (options) => available && open(options),
+    close: () => available && close(),
+    toggle: () => available && (isOpen() ? close() : open())
+  };
+}
+const DEFAULT_ACTION_LABEL = { open: "Open in canvas", collapse: "Collapse canvas" };
+function resolveToolCallValue(value, toolCall) {
+  if (typeof value === "function") {
+    return value(toolCall);
+  }
+  return value;
+}
+function resolveToolCanvasTitle(toolCall, toolDefinition) {
+  return resolveToolCallValue(toolDefinition.canvas?.title, toolCall) ?? toolDefinition.displayName ?? toolDefinition.name;
+}
+function resolveToolCanvasSubtitle(toolCall, toolDefinition) {
+  return resolveToolCallValue(toolDefinition.canvas?.subtitle, toolCall);
+}
+function resolveToolCanvasActionLabel(toolCall, toolDefinition, active) {
+  const labels = resolveToolCallValue(toolDefinition.canvas?.actionLabel, toolCall) ?? DEFAULT_ACTION_LABEL;
+  return active ? labels.collapse : labels.open;
+}
+function resolveToolCanvasIcon(toolCall, toolDefinition) {
+  const icon = resolveToolCallValue(toolDefinition.canvas?.icon, toolCall);
+  if (!icon) {
+    return void 0;
+  }
+  if (typeof icon !== "string") {
+    return icon.cloneNode(true);
+  }
+  const template = document.createElement("template");
+  template.innerHTML = icon;
+  const svg = template.content.querySelector("svg");
+  if (!svg) {
+    return void 0;
+  }
+  sanitizeSvg(svg);
+  return svg;
+}
+const SVG_ICON_ELEMENTS = /* @__PURE__ */ new Set(["svg", "g", "path", "circle", "ellipse", "rect", "line", "polyline", "polygon"]);
+const SVG_ICON_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "xmlns",
+  "viewBox",
+  "width",
+  "height",
+  "d",
+  "fill",
+  "fill-rule",
+  "clip-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "opacity",
+  "transform",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  "x",
+  "y",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "points",
+  "aria-hidden"
+]);
+function sanitizeSvg(svg) {
+  for (const element of [svg, ...svg.querySelectorAll("*")]) {
+    if (!SVG_ICON_ELEMENTS.has(element.localName)) {
+      element.remove();
+      continue;
+    }
+    for (const attribute of [...element.attributes]) {
+      if (!SVG_ICON_ATTRIBUTES.has(attribute.name)) {
+        element.removeAttribute(attribute.name);
+      }
+    }
+  }
+}
+function resolveToolCanvasInline(toolDefinition) {
+  const canvas = toolDefinition.canvas;
+  if (canvas?.inline) {
+    return canvas.inline;
+  }
+  return canvas?.open === "auto" ? "card" : "renderer";
+}
+export {
+  createToolCanvas,
+  requestCanvasClose,
+  requestCanvasOpen,
+  resolveToolCanvasActionLabel,
+  resolveToolCanvasIcon,
+  resolveToolCanvasInline,
+  resolveToolCanvasSubtitle,
+  resolveToolCanvasTitle,
+  toolCanvasHostContext
+};