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

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

@@ -1,392 +0,0 @@
-import { generateId } from "./utils.mjs";
-function withoutUiResource(toolCall) {
-  if (!toolCall.uiResource) {
-    return toolCall;
-  }
-  const { uiResource: _uiResource, ...rest } = toolCall;
-  return rest;
-}
-function responseItemWithoutUiResource(item) {
-  return item.type === "toolCall" ? { type: "toolCall", data: withoutUiResource(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`s are stripped: they 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(responseItemWithoutUiResource);
-        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 || [], withoutUiResource(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 = responseItemWithoutUiResource(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(withoutUiResource)) {
-              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
-};