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

package/dist/core/canvas-controller.mjs

@@ -1,221 +0,0 @@
-import { ContextProvider } from "@lit/context";
-import { toolCanvasHostContext, resolveToolCanvasTitle, createToolCanvas } from "../ai-chatbot/tool-canvas.mjs";
-import { shouldShowToolRenderer } from "../ai-chatbot/utils.mjs";
-class CanvasController {
-  constructor(host, config) {
-    this.#autoOpenedToolCallIds = /* @__PURE__ */ new Set();
-    this.#isOpen = false;
-    this.#content = null;
-    this.handleOpenRequest = (evt) => {
-      evt.stopPropagation();
-      const toolCall = this.#findToolCall(evt.detail.toolCallId);
-      const toolDefinition = this.#config.getTools().get(evt.detail.toolName);
-      if (!toolCall || !toolDefinition) {
-        return;
-      }
-      evt.detail.handled = this.#openToolCall({ toolCall, toolDefinition, title: evt.detail.title });
-    };
-    this.handleCloseRequest = (evt) => {
-      evt.stopPropagation();
-      evt.detail.handled = this.#closeToolCall(evt.detail.toolCallId);
-    };
-    this.#host = host;
-    this.#config = config;
-    host.addController(this);
-    this.#provider = new ContextProvider(host, {
-      context: toolCanvasHostContext,
-      initialValue: { presentation: "inline-expandable" }
-    });
-  }
-  #host;
-  #config;
-  #provider;
-  #autoOpenedToolCallIds;
-  #isOpen;
-  #content;
-  hostConnected() {
-  }
-  get isOpen() {
-    return this.#isOpen;
-  }
-  get content() {
-    return this.#content;
-  }
-  open(options = {}) {
-    return this.#commitOpen({ id: options.id, title: options.title, node: options.content });
-  }
-  /** Closes the canvas. Returns false if it was not open or the close event was prevented. */
-  close() {
-    if (!this.#isOpen) {
-      return false;
-    }
-    const event = this.#config.dispatchHostEvent({ type: this.#config.closeEvent, cancelable: true });
-    if (event.defaultPrevented) {
-      return false;
-    }
-    this.#hide();
-    return true;
-  }
-  /** Closes without asking, for when the host can no longer show the canvas (e.g. it left its conversation view). */
-  forceClose() {
-    if (!this.#isOpen) {
-      return;
-    }
-    this.#hide();
-    this.#config.dispatchHostEvent({ type: this.#config.closeEvent });
-  }
-  /** Forgets the canvas entirely, for when the thread it belonged to is gone. */
-  reset() {
-    this.forceClose();
-    this.#content = null;
-    this.#autoOpenedToolCallIds.clear();
-    this.#host.requestUpdate();
-  }
-  /** Tool calls restored from history are marked as seen so loading a thread never auto-opens the canvas. */
-  markSeen(messages) {
-    for (const message of messages) {
-      for (const toolCall of message.toolCalls ?? []) {
-        this.#autoOpenedToolCallIds.add(toolCall.id);
-      }
-    }
-  }
-  /** The tool call object is replaced on every args or status update, so open content follows it by id. */
-  syncToolCall() {
-    const content = this.#content;
-    if (!this.#isOpen || !content?.toolCall || !content.toolDefinition) {
-      return;
-    }
-    const latest = this.#findToolCall(content.toolCall.id);
-    if (!latest || latest === content.toolCall) {
-      return;
-    }
-    const { toolDefinition } = content;
-    const renderer = toolDefinition.canvas?.renderer ?? toolDefinition.renderer;
-    let node = content.node;
-    if (renderer?.elementTag && node) {
-      node.toolCall = latest;
-    } else {
-      node = this.#createRenderer(latest, toolDefinition);
-    }
-    this.#content = {
-      ...content,
-      node,
-      toolCall: latest,
-      title: content.titleOverride ?? resolveToolCanvasTitle(latest, toolDefinition)
-    };
-  }
-  /** Opens tools configured with `canvas.open: 'auto'` once their renderer shows. Call after render, not during it. */
-  autoOpenPending() {
-    const tools = this.#config.getTools();
-    if (![...tools.values()].some((tool) => tool.canvas?.open === "auto")) {
-      return;
-    }
-    for (const toolCall of this.#config.getToolCalls()) {
-      const toolDefinition = tools.get(toolCall.name);
-      if (toolDefinition?.canvas?.open !== "auto" || this.#autoOpenedToolCallIds.has(toolCall.id) || !shouldShowToolRenderer(toolCall, toolDefinition)) {
-        continue;
-      }
-      this.#autoOpenedToolCallIds.add(toolCall.id);
-      this.#openToolCall({ toolCall, toolDefinition, reason: "auto" });
-    }
-  }
-  #findToolCall(id) {
-    return this.#config.getToolCalls().find((toolCall) => toolCall.id === id);
-  }
-  #commitOpen(content, reason = "request") {
-    if (this.#config.canOpen && !this.#config.canOpen()) {
-      return false;
-    }
-    const event = this.#config.dispatchHostEvent({
-      type: this.#config.openEvent,
-      detail: { id: content.id, title: content.title, toolCall: content.toolCall },
-      cancelable: true
-    });
-    if (event.defaultPrevented) {
-      return false;
-    }
-    this.#content = content;
-    if (!this.#isOpen) {
-      this.#isOpen = true;
-      this.#config.onOpen?.({ reason });
-    }
-    this.#syncProvider();
-    this.#host.requestUpdate();
-    return true;
-  }
-  // Content stays mounted while the host collapses, then is released so hidden iframes and timers stop.
-  #hide() {
-    this.#isOpen = false;
-    this.#config.onClose?.();
-    this.#syncProvider();
-    this.#host.requestUpdate();
-    void this.#releaseAfterCollapse();
-  }
-  async #releaseAfterCollapse() {
-    const content = this.#content;
-    await this.#host.updateComplete;
-    await this.#config.collapsed?.();
-    if (!this.#isOpen && this.#content === content) {
-      this.#content = null;
-      this.#host.requestUpdate();
-    }
-  }
-  #syncProvider() {
-    this.#provider.setValue({
-      presentation: "inline-expandable",
-      openToolCallId: this.#isOpen ? this.#content?.toolCall?.id : void 0
-    });
-  }
-  #closeToolCall(toolCallId) {
-    if (this.#content?.toolCall?.id !== toolCallId) {
-      return false;
-    }
-    return this.close();
-  }
-  #openToolCall({
-    toolCall,
-    toolDefinition,
-    title,
-    reason
-  }) {
-    if (this.#isOpen && this.#content?.toolCall?.id === toolCall.id) {
-      this.#config.onRefocus?.();
-      return true;
-    }
-    return this.#commitOpen(
-      {
-        id: toolCall.id,
-        title: title ?? resolveToolCanvasTitle(toolCall, toolDefinition),
-        node: this.#createRenderer(toolCall, toolDefinition),
-        toolCall,
-        toolDefinition,
-        titleOverride: title
-      },
-      reason
-    );
-  }
-  #createControls(toolCall, toolDefinition) {
-    return createToolCanvas({
-      available: true,
-      // This instance only exists to be shown in the canvas, and is created before the canvas finishes opening.
-      isOpen: () => true,
-      open: (options) => this.#openToolCall({ toolCall, toolDefinition, title: options?.title }),
-      close: () => this.#closeToolCall(toolCall.id)
-    });
-  }
-  #createRenderer(toolCall, toolDefinition) {
-    const renderer = toolDefinition.canvas?.renderer ?? toolDefinition.renderer;
-    const canvas = this.#createControls(toolCall, toolDefinition);
-    if (renderer?.elementTag) {
-      const element = document.createElement(renderer.elementTag);
-      element.toolCall = toolCall;
-      element.presentation = "canvas";
-      element.canvas = canvas;
-      return element;
-    }
-    return renderer?.render?.(toolCall, { presentation: "canvas", canvas });
-  }
-}
-export {
-  CanvasController
-};

package/dist/core/chatbot-core-controller.d.ts

@@ -1,57 +0,0 @@
-import { ReactiveController, ReactiveControllerHost } from 'lit';
-import { AgentAdapter } from '../ai-chatbot/agent-adapter.js';
-import { ChatMessage, ClientMessageInput, FileAttachment, FileUploadCallbacks, MessageItem, ThreadState, ToolCall, AnyToolDefinition } from '../ai-chatbot/types.js';
-export interface ChatbotCoreCallbacks {
-    onRequestUpdate: () => void;
-    onScrollToBottom: () => void;
-    onDispatchEvent: (type: string, detail?: unknown, cancelable?: boolean) => CustomEvent;
-}
-export interface ChatbotCoreControllerConfig {
-    callbacks: ChatbotCoreCallbacks;
-}
-export declare class ChatbotCoreController implements ReactiveController {
-    #private;
-    constructor(host: ReactiveControllerHost, config: ChatbotCoreControllerConfig);
-    hostConnected(): void;
-    hostDisconnected(): void;
-    get adapter(): AgentAdapter | undefined;
-    set adapter(value: AgentAdapter | undefined);
-    get messageItems(): MessageItem[];
-    get isStreaming(): boolean;
-    get isUploading(): boolean;
-    get hasMessages(): boolean;
-    get tools(): Map<string, AnyToolDefinition>;
-    get pendingAttachments(): FileAttachment[];
-    get completedAttachments(): FileAttachment[];
-    sendMessage(config: {
-        content: string;
-        timestamp?: number;
-        attachments?: FileAttachment[];
-    }): Promise<void>;
-    processFileUpload(file: File, timestamp: number): string;
-    createFileUploadCallbacks(fileId: string): FileUploadCallbacks;
-    abortFileUpload(fileId: string): void;
-    removeCompletedAttachment(attachmentId: string): void;
-    getMessage(id: string): ChatMessage | undefined;
-    getToolCall(id: string): ToolCall | undefined;
-    clearMessages(): void;
-    getMessages(): ChatMessage[];
-    setMessages(messages: ChatMessage[]): void;
-    updateMessageContent(id: string, content: string): void;
-    /** Tool call ids rendered at or after `index` in {@link messageItems}. */
-    getToolCallIdsFrom(index: number): string[];
-    removeMessageItemsFrom(index: number): void;
-    setResponseFeedback(responseId: string, feedback: {
-        type: 'positive' | 'negative';
-        reason?: string;
-    }): void;
-    addMessage(message: ChatMessage): void;
-    addClientMessage(message: ClientMessageInput): string;
-    removeClientMessage(id: string): void;
-    /** Finalizes the in-progress response (if any) so a client message inserted right after it doesn't trail a live bubble. */
-    finalizeActiveResponse(): void;
-    getThreadState(): ThreadState;
-    setThreadState(state: ThreadState): void;
-    abort(): void;
-    canSendMessage(): boolean;
-}