@tylertech/forge-ai 0.15.3-dev.1 → 0.16.0-dev.0

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

@@ -1,392 +0,0 @@
-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;
-    this._config = _config;
-    this._messageItems = [];
-    this._toolCalls = /* @__PURE__ */ new Map();
-    this._activeResponse = null;
-    _host.addController(this);
-  }
-  hostConnected() {
-  }
-  hostDisconnected() {
-    this._messageItems = [];
-    this._toolCalls.clear();
-    this._activeResponse = null;
-  }
-  updateConfig(config) {
-    this._config = { ...this._config, ...config };
-  }
-  get messageItems() {
-    return this._messageItems;
-  }
-  getToolCall(id) {
-    return this._toolCalls.get(id);
-  }
-  getActiveResponse() {
-    return this._activeResponse;
-  }
-  startResponse() {
-    if (this._activeResponse) {
-      return this._activeResponse;
-    }
-    const response = {
-      id: generateId(),
-      children: [],
-      status: "streaming",
-      timestamp: Date.now()
-    };
-    this._activeResponse = response;
-    this._messageItems = [...this._messageItems, { type: "assistant", data: response }];
-    this.#notifyStateChange();
-    return response;
-  }
-  markResponseThinking() {
-    if (!this._activeResponse || this._activeResponse.isThinking) {
-      return;
-    }
-    this._activeResponse.isThinking = true;
-    this.#updateResponseInItems();
-    this.#notifyStateChange();
-  }
-  clearResponseThinking() {
-    if (!this._activeResponse || !this._activeResponse.isThinking) {
-      return;
-    }
-    this._activeResponse.isThinking = false;
-    this.#updateResponseInItems();
-    this.#notifyStateChange();
-  }
-  addTextToResponse(messageId, content) {
-    const response = this._activeResponse ?? this.startResponse();
-    response.isThinking = false;
-    const lastChild = response.children[response.children.length - 1];
-    if (lastChild?.type === "text" && lastChild.messageId === messageId) {
-      lastChild.content = content;
-      lastChild.status = "streaming";
-    } else {
-      response.children.push({ type: "text", messageId, content, status: "streaming" });
-    }
-    this.#updateResponseInItems();
-    this.#notifyStateChange();
-  }
-  appendTextDelta(messageId, delta) {
-    const response = this._activeResponse ?? this.startResponse();
-    response.isThinking = false;
-    const lastChild = response.children[response.children.length - 1];
-    if (lastChild?.type === "text" && lastChild.messageId === messageId) {
-      lastChild.content += delta;
-    } else {
-      response.children.push({ type: "text", messageId, content: delta, status: "streaming" });
-    }
-    this.#updateResponseInItems();
-    this.#notifyStateChange();
-  }
-  markTextComplete(messageId) {
-    if (!this._activeResponse) {
-      return;
-    }
-    const textChild = [...this._activeResponse.children].reverse().find((c) => c.type === "text" && c.messageId === messageId);
-    if (textChild && textChild.type === "text") {
-      textChild.status = "complete";
-    }
-    this.#updateResponseInItems();
-    this.#notifyStateChange();
-  }
-  addToolCallToResponse(toolCall) {
-    const response = this._activeResponse ?? this.startResponse();
-    response.isThinking = false;
-    const toolCallWithTimestamp = { ...toolCall, startTimestamp: Date.now() };
-    this._toolCalls.set(toolCall.id, toolCallWithTimestamp);
-    response.children.push({ type: "toolCall", data: toolCallWithTimestamp });
-    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 isFinishing = updates.status === "complete" || updates.status === "error" || updates.status === "cancelled";
-    const updated = {
-      ...toolCall,
-      ...updates,
-      ...isFinishing && !toolCall.endTimestamp ? { endTimestamp: Date.now() } : {}
-    };
-    this._toolCalls.set(toolCallId, updated);
-    this.#replaceToolCall(updated);
-    this.#notifyStateChange();
-  }
-  completeToolCallInResponse(toolCallId, result, event) {
-    this.updateToolCallInResponse(toolCallId, {
-      result,
-      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() {
-    if (!this._activeResponse) {
-      return;
-    }
-    this._activeResponse.status = "complete";
-    this.#updateResponseInItems();
-    this._activeResponse = null;
-    this.#notifyStateChange();
-    this._config.onThreadSettled?.();
-  }
-  #updateResponseInItems() {
-    const activeResponse = this._activeResponse;
-    if (!activeResponse) {
-      return;
-    }
-    this._messageItems = this._messageItems.map((item) => {
-      if (item.type === "assistant" && item.data.id === activeResponse.id) {
-        return { type: "assistant", data: { ...activeResponse } };
-      }
-      return item;
-    });
-  }
-  #notifyStateChange() {
-    this._host.requestUpdate();
-  }
-  addMessageItem(item) {
-    this._messageItems = [...this._messageItems, item];
-    this.#notifyStateChange();
-  }
-  addMessage(message) {
-    this.tryFinalizeResponse();
-    const existing = this.getMessage(message.id);
-    if (existing) {
-      return;
-    }
-    this.addMessageItem({ type: "message", data: message });
-    if (message.status === "complete" || message.status === "error") {
-      this._config.onThreadSettled?.();
-    }
-  }
-  getMessage(id) {
-    const item = this._messageItems.find((i) => i.type === "message" && i.data.id === id);
-    return item?.type === "message" ? item.data : void 0;
-  }
-  /**
-   * Inserts or upserts a client-only message, never touching `_activeResponse`.
-   * Unlike {@link addMessage}, this never finalizes an in-progress response -
-   * safe to call while a real reply is streaming.
-   */
-  addClientMessage(message) {
-    const id = message.id ?? generateId();
-    const chatMessage = {
-      id,
-      role: "system",
-      content: message.content,
-      timestamp: Date.now(),
-      status: "complete",
-      clientOnly: true,
-      kind: message.kind,
-      header: message.header,
-      actions: message.actions
-    };
-    this._messageItems = [
-      ...this._messageItems.filter((item) => !(item.type === "message" && item.data.id === id)),
-      { type: "message", data: chatMessage }
-    ];
-    this.#notifyStateChange();
-    return id;
-  }
-  /** Removes a client message by id. No-ops if not found. Safe to call at any time. */
-  removeClientMessage(id) {
-    const hasMessage = this._messageItems.some((item) => item.type === "message" && item.data.id === id);
-    if (!hasMessage) {
-      return;
-    }
-    this._messageItems = this._messageItems.filter((item) => !(item.type === "message" && item.data.id === id));
-    this.#notifyStateChange();
-  }
-  updateMessageStatus(id, status) {
-    this._messageItems = this._messageItems.map((item) => {
-      if (item.type === "message" && item.data.id === id) {
-        return { ...item, data: { ...item.data, status } };
-      }
-      return item;
-    });
-    this.#notifyStateChange();
-    if (status === "complete" || status === "error") {
-      this._config.onThreadSettled?.();
-    }
-  }
-  updateMessageContent(id, content) {
-    this._messageItems = this._messageItems.map((item) => {
-      if (item.type === "message" && item.data.id === id) {
-        return { ...item, data: { ...item.data, content } };
-      }
-      return item;
-    });
-    this.#notifyStateChange();
-  }
-  removeMessageItem(index) {
-    this._messageItems = this._messageItems.filter((_, i) => i !== index);
-    this.#notifyStateChange();
-  }
-  clearMessages() {
-    this._messageItems = [];
-    this._toolCalls.clear();
-    this._activeResponse = null;
-    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 = [];
-    for (const item of this._messageItems) {
-      if (item.type === "message") {
-        messages.push({ ...item.data, toolCalls: [] });
-      } else if (item.type === "assistant") {
-        const response = item.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",
-          content: textContent,
-          timestamp: response.timestamp,
-          status: response.status === "streaming" ? "streaming" : response.status === "error" ? "error" : "complete",
-          toolCalls: toolCalls.length ? toolCalls : void 0,
-          feedback: response.feedback,
-          children
-        };
-        messages.push(message);
-      } else if (item.type === "toolCall") {
-        const lastMsg = messages[messages.length - 1];
-        if (lastMsg && lastMsg.role === "assistant") {
-          lastMsg.toolCalls = [...lastMsg.toolCalls || [], withoutMcpAppResource(item.data)];
-        }
-      }
-    }
-    return messages;
-  }
-  setMessages(messages) {
-    const messageItems = [];
-    this._toolCalls.clear();
-    this._activeResponse = null;
-    for (const msg of messages) {
-      if (msg.role === "assistant" && msg.status !== "error") {
-        let children;
-        if (msg.children?.length) {
-          children = msg.children.map((child) => {
-            const restored = responseItemWithoutMcpAppResource(child);
-            if (restored.type === "toolCall") {
-              this._toolCalls.set(restored.data.id, restored.data);
-            }
-            return restored;
-          });
-        } else {
-          children = [];
-          if (msg.content?.trim()) {
-            children.push({ type: "text", messageId: msg.id, content: msg.content, status: "complete" });
-          }
-          if (msg.toolCalls) {
-            for (const toolCall of msg.toolCalls.map(withoutMcpAppResource)) {
-              children.push({ type: "toolCall", data: toolCall });
-              this._toolCalls.set(toolCall.id, toolCall);
-            }
-          }
-        }
-        const response = {
-          id: msg.id,
-          children,
-          status: msg.status === "streaming" ? "streaming" : "complete",
-          timestamp: msg.timestamp,
-          feedback: msg.feedback
-        };
-        messageItems.push({ type: "assistant", data: response });
-      } else {
-        messageItems.push({ type: "message", data: { ...msg, toolCalls: void 0 } });
-      }
-    }
-    this._messageItems = messageItems;
-    this.#notifyStateChange();
-  }
-  setResponseFeedback(responseId, feedback) {
-    const item = this._messageItems.find((i) => i.type === "assistant" && i.data.id === responseId);
-    if (item?.type === "assistant") {
-      item.data.feedback = feedback;
-      this.#notifyStateChange();
-    }
-  }
-}
-export {
-  MessageStateController
-};

package/dist/ai-chatbot/request-serialization.d.ts

@@ -1,33 +0,0 @@
-import { ChatMessage, ToolCall } from './types.js';
-/**
- * Wire shape for a tool call sent back to an agent endpoint: the final `args`
- * and its `result`, and nothing else. Local-only fields (`eventStream`,
- * `argsBuffer`, `children`, timing metadata) are deliberately absent - no
- * backend reads them and they grow without bound across turns.
- */
-export interface RequestToolCall {
-    id: string;
-    name: string;
-    args: Record<string, unknown>;
-    status: ToolCall['status'];
-    result?: unknown;
-}
-/** Wire shape for a single message sent to an agent endpoint. */
-export interface RequestMessage {
-    role: ChatMessage['role'];
-    content: string;
-    toolCallId?: string;
-    toolCalls?: RequestToolCall[];
-}
-/**
- * Projects a tool call onto its wire shape. This is the single boundary at which
- * local state is dropped, so adapters never have to remember to omit it.
- */
-export declare function toRequestToolCall(toolCall: ToolCall): RequestToolCall;
-/**
- * Projects the thread onto the messages an agent endpoint is sent: client-only
- * messages and empty assistant turns are dropped, and every remaining message is
- * rebuilt field by field rather than spread, so no local state can leak into a
- * request body.
- */
-export declare function toRequestMessages(messages: ChatMessage[]): RequestMessage[];

package/dist/ai-chatbot/request-serialization.mjs

@@ -1,31 +0,0 @@
-function toRequestToolCall(toolCall) {
-  const { id, name, args, status, result } = toolCall;
-  return {
-    id,
-    name,
-    args,
-    status,
-    ...result === void 0 ? {} : { result }
-  };
-}
-function toRequestMessages(messages) {
-  return messages.filter(isSendableMessage).map((message) => ({
-    role: message.role,
-    content: message.content,
-    ...message.toolCallId ? { toolCallId: message.toolCallId } : {},
-    ...message.toolCalls?.length ? { toolCalls: message.toolCalls.map(toRequestToolCall) } : {}
-  }));
-}
-function isSendableMessage(message) {
-  if (message.clientOnly) {
-    return false;
-  }
-  if (message.role === "assistant") {
-    return message.content.trim().length > 0 || !!message.toolCalls?.length;
-  }
-  return true;
-}
-export {
-  toRequestMessages,
-  toRequestToolCall
-};

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

@@ -1,128 +0,0 @@
-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
-};