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

package/dist/ai-chatbot/agent-adapter.d.ts

@@ -1,4 +1,4 @@
-import { ChatMessage, FileUploadCallbacks, ToolDefinition } from './types.js';
+import { ChatMessage, FileUploadCallbacks, McpAppUiResource, McpToolResult, AnyToolDefinition } from './types.js';
 import { EventEmitter, Subscription } from './event-emitter.js';
 export interface MessageStartEvent {
     messageId: string;
@@ -44,11 +44,70 @@ export interface ToolCallEndEvent {
 }
 export interface ToolResultEvent {
     toolCallId: string;
+    /** Model-facing result. Never delivered to an MCP-app View. */
     result: unknown;
     message: ChatMessage;
+    /** Companion structured payload delivered to an MCP-app widget, stripped from LLM context. */
+    structuredContent?: unknown;
+    /** `true` when the backend dropped `structuredContent` (size caps). */
+    structuredContentOmitted?: boolean;
+    /** Raw MCP result for an MCP-app tool call; the View's `tool-result` is built from it. */
+    mcpResult?: McpToolResult;
+    /** `true` when the backend dropped `mcpResult` (size caps). */
+    mcpResultOmitted?: boolean;
     isError?: boolean;
+    /** `true` when the tool call was cancelled rather than failed; takes precedence over `isError`. */
+    cancelled?: boolean;
     rawEvent?: unknown;
 }
+/**
+ * Emitted when the backend signals that a tool call is backed by an MCP-app UI
+ * resource. Carries only the widget binding — the HTML and the `csp`/`permissions`
+ * policy come from {@link AgentAdapter.resolveMcpAppResource}. The core controller
+ * resolves the resource and stamps a {@link McpAppUiResource} onto the tool call.
+ *
+ * May be emitted before or after the matching `tool-call` chunk, and also after
+ * `setMessages`/`setThreadState` to remount widgets restored from history.
+ */
+export interface McpUiResourceEvent {
+    toolCallId: string;
+    toolName?: string;
+    /** The concrete resolved `ui://` URI (interpolation done server-side). */
+    resourceUri: string;
+    serverId?: string;
+    mimeType?: string;
+    rawEvent?: unknown;
+}
+/** Parameters for {@link AgentAdapter.resolveMcpAppResource}. */
+export interface McpAppResourceResolveParams {
+    /** The concrete resolved `ui://` URI from the `mcp-ui-resource` event. */
+    resourceUri: string;
+    /** The widget's tool call id; template reads are bound to it. */
+    toolCallId: string;
+}
+/**
+ * Parameters an MCP-app widget passes when forwarding a `tools/call` to the server.
+ * The library never owns a `Client`; these delegate to the adapter.
+ */
+export interface McpToolCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+    /** The calling widget's tool call id; the backend derives the MCP server from it. */
+    toolCallId: string;
+}
+/** Parameters for an MCP-app widget-initiated `resources/read`. */
+export interface McpResourceReadParams {
+    uri: string;
+    /** The calling widget's tool call id. */
+    toolCallId: string;
+}
+/** Payload of a widget's `ui/update-model-context`, forwarded to the adapter. */
+export interface McpModelContextUpdateParams {
+    /** The widget's tool call id. */
+    toolCallId: string;
+    content?: unknown[];
+    structuredContent?: unknown;
+}
 export interface AdapterState {
     isConnected: boolean;
     isConnecting: boolean;
@@ -108,7 +167,7 @@ export interface ActivityDeltaAgentEvent {
 }
 export declare abstract class AgentAdapter {
     protected _state: AdapterState;
-    protected _tools: ToolDefinition[];
+    protected _tools: AnyToolDefinition[];
     protected _events: {
         runStarted: EventEmitter<void>;
         runFinished: EventEmitter<void>;
@@ -121,6 +180,7 @@ export declare abstract class AgentAdapter {
         toolCallArgs: EventEmitter<ToolCallArgsEvent>;
         toolCallEnd: EventEmitter<ToolCallEndEvent>;
         toolResult: EventEmitter<ToolResultEvent>;
+        mcpUiResource: EventEmitter<McpUiResourceEvent>;
         fileUpload: EventEmitter<FileUploadEvent>;
         fileRemove: EventEmitter<FileRemoveEvent>;
         error: EventEmitter<ErrorEvent>;
@@ -143,8 +203,46 @@ export declare abstract class AgentAdapter {
     abstract get threadId(): string;
     abstract set threadId(value: string);
     clearMemory?(): Promise<void>;
-    setTools(tools: ToolDefinition[]): void;
-    getTools(): ToolDefinition[];
+    /**
+     * Resolve the MCP-app UI resource for an already-resolved `resourceUri`, bound to the
+     * widget's `toolCallId`. The adapter fetches the template for that concrete URI and
+     * fills `csp`/`permissions` from the template response's `_meta.ui` (`{}` when absent).
+     * It MUST NOT re-derive the URI (templated-URI interpolation is server-side only).
+     */
+    resolveMcpAppResource?(params: McpAppResourceResolveParams): Promise<McpAppUiResource | undefined>;
+    /**
+     * Forward a widget-initiated `tools/call` to the MCP server. Resolve with the View's
+     * `CallToolResult` (tool-level errors resolve with `isError: true`); reject for
+     * transport/HTTP errors (e.g. a 403 for a tool without `"app"` visibility) — the
+     * rejection is returned to the View as a JSON-RPC error.
+     */
+    callMcpTool?(params: McpToolCallParams): Promise<unknown>;
+    /**
+     * Forward a widget-initiated `resources/read` to the MCP server. When not implemented
+     * the View's request is rejected with a JSON-RPC error.
+     */
+    readMcpResource?(params: McpResourceReadParams): Promise<unknown>;
+    /**
+     * Called when a widget sends `ui/update-model-context`. Each call replaces the previous
+     * context for that `toolCallId`; adapters should debounce and may hold the latest value
+     * until the run ends.
+     */
+    updateMcpModelContext?(params: McpModelContextUpdateParams): Promise<void>;
+    /**
+     * Called after a widget is torn down (its turn left the visible thread, or the thread was
+     * cleared/replaced). Drop any state held for that `toolCallId`, e.g. a pending model context.
+     */
+    disposeMcpAppView?(params: {
+        toolCallId: string;
+    }): void;
+    setTools(tools: AnyToolDefinition[]): void;
+    getTools(): AnyToolDefinition[];
+    /**
+     * Tools to forward to the backend agent, excluding MCP-app tools (`ToolDefinition.mcpApp`).
+     * MCP-app tools are a host-internal mechanism for streaming a UI resource into an existing
+     * tool call — the model never calls them directly, so they must never reach the agent.
+     */
+    getModelFacingTools(): AnyToolDefinition[];
     getState(): AdapterState;
     get isConnected(): boolean;
     get isConnecting(): boolean;
@@ -160,6 +258,7 @@ export declare abstract class AgentAdapter {
     onToolCallArgs(callback: (event: ToolCallArgsEvent) => void): Subscription;
     onToolCallEnd(callback: (event: ToolCallEndEvent) => void): Subscription;
     onToolCallResult(callback: (event: ToolResultEvent) => void): Subscription;
+    onMcpUiResource(callback: (event: McpUiResourceEvent) => void): Subscription;
     onFileUpload(callback: (event: FileUploadEvent) => void): Subscription;
     onFileRemove(callback: (event: FileRemoveEvent) => void): Subscription;
     onError(callback: (event: ErrorEvent) => void): Subscription;
@@ -184,6 +283,14 @@ export declare abstract class AgentAdapter {
     protected _emitToolCallArgs(event: ToolCallArgsEvent, rawEvent?: unknown): void;
     protected _emitToolCallEnd(event: ToolCallEndEvent, rawEvent?: unknown): void;
     protected _emitToolResult(event: ToolResultEvent, rawEvent?: unknown): void;
+    /**
+     * Announce that a tool call renders as an MCP-app widget. Also the way to remount
+     * widgets restored from history: call it per widget after `setMessages`/`setThreadState`
+     * — the resource is resolved and stamped onto the restored (already finalized) tool
+     * call. If the tool call isn't in state yet, the resource is held and applied when it
+     * arrives.
+     */
+    protected _emitMcpUiResource(event: McpUiResourceEvent, rawEvent?: unknown): void;
     emitFileUpload(file: File, callbacks: FileUploadCallbacks): void;
     emitFileRemove(fileId: string, callbacks: {
         onSuccess: () => void;

package/dist/ai-chatbot/agent-adapter.mjs

@@ -15,6 +15,7 @@ class AgentAdapter {
       toolCallArgs: new EventEmitter(),
       toolCallEnd: new EventEmitter(),
       toolResult: new EventEmitter(),
+      mcpUiResource: new EventEmitter(),
       fileUpload: new EventEmitter(),
       fileRemove: new EventEmitter(),
       error: new EventEmitter(),
@@ -36,6 +37,14 @@ class AgentAdapter {
   getTools() {
     return [...this._tools];
   }
+  /**
+   * Tools to forward to the backend agent, excluding MCP-app tools (`ToolDefinition.mcpApp`).
+   * MCP-app tools are a host-internal mechanism for streaming a UI resource into an existing
+   * tool call — the model never calls them directly, so they must never reach the agent.
+   */
+  getModelFacingTools() {
+    return this._tools.filter((tool) => tool.mcpApp === void 0);
+  }
   getState() {
     return { ...this._state };
   }
@@ -81,6 +90,9 @@ class AgentAdapter {
   onToolCallResult(callback) {
     return this._events.toolResult.subscribe(callback);
   }
+  onMcpUiResource(callback) {
+    return this._events.mcpUiResource.subscribe(callback);
+  }
   onFileUpload(callback) {
     return this._events.fileUpload.subscribe(callback);
   }
@@ -153,6 +165,16 @@ class AgentAdapter {
   _emitToolResult(event, rawEvent) {
     this._events.toolResult.emit({ ...event, rawEvent });
   }
+  /**
+   * Announce that a tool call renders as an MCP-app widget. Also the way to remount
+   * widgets restored from history: call it per widget after `setMessages`/`setThreadState`
+   * — the resource is resolved and stamped onto the restored (already finalized) tool
+   * call. If the tool call isn't in state yet, the resource is held and applied when it
+   * arrives.
+   */
+  _emitMcpUiResource(event, rawEvent) {
+    this._events.mcpUiResource.emit({ ...event, rawEvent });
+  }
   emitFileUpload(file, callbacks) {
     this._events.fileUpload.emit({ file, ...callbacks });
   }

package/dist/ai-chatbot/agent-runner.d.ts

@@ -1,12 +1,12 @@
 import { AgentAdapter } from './agent-adapter.js';
-import { ChatMessage, ToolCall, ToolDefinition } from './types.js';
+import { ChatMessage, ToolCall, AnyToolDefinition } from './types.js';
 export interface AgentRunnerConfig {
     /** The adapter instance that handles communication with the AI model */
     adapter: AgentAdapter;
     /** The user prompt to send to the agent */
     prompt: string;
     /** Optional tools the agent can call during execution */
-    tools?: ToolDefinition[];
+    tools?: AnyToolDefinition[];
     /** Execution mode: 'one-shot' stops after first response, 'multi-turn' allows tool usage loops. @default 'one-shot' */
     mode?: 'one-shot' | 'multi-turn';
     /** Maximum conversation turns in multi-turn mode to prevent infinite loops. @default 20 */

package/dist/ai-chatbot/ai-chatbot-base.d.ts

@@ -10,9 +10,10 @@ import { ForgeAiSuggestionsEventData, Suggestion } from '../ai-suggestions';
 import { ForgeAiVoiceInputResultEvent } from '../ai-voice-input';
 import { AgentAdapter } from './agent-adapter.js';
 import { ChatbotCoreController } from '../core/chatbot-core-controller.js';
-import { Agent, ChatMessage, ClientMessageInput, ContextItem, HeadingLevel, MessageItem, SlashCommand, ThreadState, ToolDefinition } from './types.js';
+import { Agent, ChatMessage, ClientMessageInput, ContextItem, HeadingLevel, MessageItem, SlashCommand, ThreadState, ToolCall, AnyToolDefinition } from './types.js';
 export type FeatureToggle = 'on' | 'off';
 export declare abstract class AiChatbotBase extends LitElement {
+    #private;
     protected abstract _messageThreadRef: Ref<AiMessageThreadComponent>;
     protected abstract _promptRef: Ref<AiPromptComponent>;
     adapter?: AgentAdapter;
@@ -34,14 +35,34 @@ export declare abstract class AiChatbotBase extends LitElement {
     agents: Agent[];
     selectedAgentId?: string;
     contextItems: ContextItem[];
+    mcpAppSandboxUrl?: string;
+    /**
+     * Theme fed into an MCP-app widget's `hostContext.theme`. The chatbot's own appearance
+     * comes from Forge tokens and is unaffected. Set this whenever the app switches between
+     * light and dark: it is the signal that re-sends `theme` and the Forge-derived
+     * `styles.variables` to widgets, since token changes alone can't be detected. Absent →
+     * follows `prefers-color-scheme`.
+     */
+    mcpAppTheme?: 'light' | 'dark';
+    private _mcpAppHost;
+    /**
+     * Sends `ui/resource-teardown` to mounted MCP-app widgets (all, or only `toolCallIds`) and
+     * releases them immediately, without waiting for acks. The adapter then drops any state it
+     * holds for them (e.g. a pending model context).
+     */
+    protected _teardownMcpAppViews({ toolCallIds }?: {
+        toolCallIds?: string[];
+    }): void;
     protected _coreController: ChatbotCoreController;
     protected get _isStreaming(): boolean;
     protected get _isUploading(): boolean;
-    protected get _tools(): Map<string, ToolDefinition>;
+    protected get _tools(): Map<string, AnyToolDefinition>;
     protected get _messageItems(): MessageItem[];
+    protected get _toolCalls(): ToolCall[];
     protected get _hasMessages(): boolean;
     protected get _allContextItems(): ContextItem[];
     connectedCallback(): void;
+    disconnectedCallback(): void;
     willUpdate(changedProperties: PropertyValues<this>): void;
     protected _onConnected(): void;
     protected get _slashCommands(): SlashCommand[];
@@ -136,6 +157,12 @@ export declare abstract class AiChatbotBase extends LitElement {
     removeClientMessage(id: string): void;
     sendMessage(content: string, files?: File[]): Promise<void>;
     abort(): void;
+    /**
+     * Re-sends the Forge-derived `styles.variables` to every MCP-app widget. Call after
+     * changing Forge tokens without a light/dark switch (e.g. a brand change); for light/dark,
+     * set {@link mcpAppTheme} instead.
+     */
+    refreshMcpAppStyles(): void;
     scrollToBottom({ behavior }?: {
         behavior?: ScrollBehavior;
     }): Promise<void>;

package/dist/ai-chatbot/ai-chatbot-base.mjs

@@ -1,5 +1,7 @@
+import { provide } from "@lit/context";
 import { LitElement } from "lit";
 import { property } from "lit/decorators.js";
+import { mcpAppHostContext } from "../tools/ai-mcp-app/mcp-app-context.mjs";
 import { ChatbotCoreController } from "../core/chatbot-core-controller.mjs";
 import { fileAttachmentsToContextItems, generateId, formatChatTranscript, downloadFile, createChatExportFilename } from "./utils.mjs";
 var __defProp = Object.defineProperty;
@@ -11,6 +13,34 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (result) __defProp(target, key, result);
   return result;
 };
+function mcpAppHostCapabilities(adapter) {
+  return {
+    openLinks: {},
+    logging: {},
+    message: { text: {} },
+    ...typeof adapter?.callMcpTool === "function" ? { serverTools: {} } : {},
+    ...typeof adapter?.updateMcpModelContext === "function" ? { updateModelContext: { text: {}, structuredContent: {} } } : {}
+  };
+}
+function mcpAppEnvironment() {
+  return {
+    availableDisplayModes: ["inline", "fullscreen", "pip"],
+    locale: navigator.language,
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    userAgent: navigator.userAgent,
+    platform: "web",
+    deviceCapabilities: {
+      touch: window.matchMedia("(pointer: coarse)").matches || navigator.maxTouchPoints > 0,
+      hover: window.matchMedia("(hover: hover)").matches
+    },
+    safeAreaInsets: { top: 0, right: 0, bottom: 0, left: 0 }
+  };
+}
+function mcpMessageText(content) {
+  return content.filter(
+    (block) => !!block && typeof block === "object" && block.type === "text" && typeof block.text === "string"
+  ).map((block) => block.text).join("\n\n");
+}
 class AiChatbotBase extends LitElement {
   constructor() {
     super(...arguments);
@@ -29,6 +59,74 @@ class AiChatbotBase extends LitElement {
     this.clearOption = "on";
     this.agents = [];
     this.contextItems = [];
+    this.#themeMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    this.#mcpAppViews = /* @__PURE__ */ new Map();
+    this._mcpAppHost = {
+      callTool: (params) => this._coreController?.adapter?.callMcpTool?.(params) ?? Promise.reject(new Error("tools/call is not supported by this host")),
+      readResource: (params) => this._coreController?.adapter?.readMcpResource?.(params) ?? Promise.reject(new Error("resources/read is not supported by this host")),
+      updateModelContext: (params) => this._coreController?.adapter?.updateMcpModelContext?.(params) ?? Promise.resolve(),
+      draftMessage: ({ content }) => this.#draftMcpAppMessage(content),
+      teardownView: ({ toolCallId }) => this._teardownMcpAppViews({ toolCallIds: [toolCallId] }),
+      registerView: (view) => {
+        this.#mcpAppViews.set(view.toolCallId, view);
+        return () => {
+          if (this.#mcpAppViews.get(view.toolCallId) === view) {
+            this.#mcpAppViews.delete(view.toolCallId);
+          }
+        };
+      },
+      hostContext: { theme: this.#effectiveTheme, ...mcpAppEnvironment() },
+      sandboxUrl: void 0,
+      hostCapabilities: mcpAppHostCapabilities(void 0)
+    };
+    this.#handleThemeChange = () => {
+      this.#refreshMcpAppHostContext();
+    };
+  }
+  #themeMediaQuery;
+  get #effectiveTheme() {
+    return this.mcpAppTheme ?? (this.#themeMediaQuery.matches ? "dark" : "light");
+  }
+  #mcpAppViews;
+  /**
+   * Places a widget's `ui/message` text in the prompt for the user to review and send. A
+   * widget never starts a model turn on its own. Refused when the message has no text.
+   */
+  async #draftMcpAppMessage(content) {
+    const text = mcpMessageText(content);
+    const prompt = this._promptRef.value;
+    if (!text.trim() || !prompt) {
+      return { isError: true };
+    }
+    prompt.value = text;
+    prompt.focus();
+    return {};
+  }
+  /**
+   * Sends `ui/resource-teardown` to mounted MCP-app widgets (all, or only `toolCallIds`) and
+   * releases them immediately, without waiting for acks. The adapter then drops any state it
+   * holds for them (e.g. a pending model context).
+   */
+  _teardownMcpAppViews({ toolCallIds } = {}) {
+    const views = [...this.#mcpAppViews.values()].filter((view) => toolCallIds?.includes(view.toolCallId) ?? true);
+    for (const view of views) {
+      this.#mcpAppViews.delete(view.toolCallId);
+      view.teardown();
+      this._coreController?.adapter?.disposeMcpAppView?.({ toolCallId: view.toolCallId });
+    }
+  }
+  /** Tears down widgets rendered at or after `index`, then removes those items. */
+  #removeMessageItemsFrom(index) {
+    this._teardownMcpAppViews({ toolCallIds: this._coreController.getToolCallIdsFrom(index) });
+    this._coreController.removeMessageItemsFrom(index);
+  }
+  #handleThemeChange;
+  /** A new host context object makes every widget re-read its Forge styles and notify its View. */
+  #refreshMcpAppHostContext() {
+    this._mcpAppHost = {
+      ...this._mcpAppHost,
+      hostContext: { ...this._mcpAppHost.hostContext, theme: this.#effectiveTheme }
+    };
   }
   get _isStreaming() {
     return this._coreController?.isStreaming ?? false;
@@ -42,6 +140,17 @@ class AiChatbotBase extends LitElement {
   get _messageItems() {
     return this._coreController?.messageItems ?? [];
   }
+  get _toolCalls() {
+    return this._messageItems.flatMap((item) => {
+      if (item.type === "toolCall") {
+        return [item.data];
+      }
+      if (item.type === "assistant") {
+        return item.data.children.flatMap((child) => child.type === "toolCall" ? [child.data] : []);
+      }
+      return [];
+    });
+  }
   get _hasMessages() {
     return this._coreController?.hasMessages ?? false;
   }
@@ -66,12 +175,26 @@ class AiChatbotBase extends LitElement {
     if (this.adapter) {
       this._coreController.adapter = this.adapter;
     }
+    this.#themeMediaQuery.addEventListener("change", this.#handleThemeChange);
     this._onConnected();
   }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.#themeMediaQuery.removeEventListener("change", this.#handleThemeChange);
+  }
   willUpdate(changedProperties) {
     if (changedProperties.has("adapter") && this._coreController) {
       this._coreController.adapter = this.adapter;
     }
+    if (changedProperties.has("adapter")) {
+      this._mcpAppHost = { ...this._mcpAppHost, hostCapabilities: mcpAppHostCapabilities(this.adapter) };
+    }
+    if (changedProperties.has("mcpAppSandboxUrl")) {
+      this._mcpAppHost = { ...this._mcpAppHost, sandboxUrl: this.mcpAppSandboxUrl };
+    }
+    if (changedProperties.has("mcpAppTheme")) {
+      this.#refreshMcpAppHostContext();
+    }
   }
   _onConnected() {
   }
@@ -239,7 +362,7 @@ class AiChatbotBase extends LitElement {
     }
     const responseIndex = messageIndex + 1;
     if (responseIndex < this._messageItems.length) {
-      this._coreController.removeMessageItemsFrom(responseIndex);
+      this.#removeMessageItemsFrom(responseIndex);
     }
     adapter.sendMessage(this.getMessages());
   }
@@ -256,7 +379,7 @@ class AiChatbotBase extends LitElement {
     this._coreController.updateMessageContent(messageId, content);
     const responseIndex = messageIndex + 1;
     if (responseIndex < this._messageItems.length) {
-      this._coreController.removeMessageItemsFrom(responseIndex);
+      this.#removeMessageItemsFrom(responseIndex);
     }
     adapter.sendMessage(this.getMessages());
   }
@@ -272,7 +395,7 @@ class AiChatbotBase extends LitElement {
     if (responseIndex === -1) {
       return;
     }
-    this._coreController.removeMessageItemsFrom(responseIndex);
+    this.#removeMessageItemsFrom(responseIndex);
     adapter.sendMessage(this.getMessages());
   }
   _handleFeedback(evt, type) {
@@ -348,6 +471,7 @@ class AiChatbotBase extends LitElement {
     if (event.defaultPrevented) {
       return false;
     }
+    this._teardownMcpAppViews();
     this._coreController.clearMessages();
     return true;
   }
@@ -365,6 +489,7 @@ class AiChatbotBase extends LitElement {
    * resetting thread IDs or closing panels.
    */
   startNewChat() {
+    this._teardownMcpAppViews();
     this._coreController.clearMessages();
   }
   getMessages() {
@@ -431,6 +556,14 @@ class AiChatbotBase extends LitElement {
   abort() {
     this._handleStop();
   }
+  /**
+   * Re-sends the Forge-derived `styles.variables` to every MCP-app widget. Call after
+   * changing Forge tokens without a light/dark switch (e.g. a brand change); for light/dark,
+   * set {@link mcpAppTheme} instead.
+   */
+  refreshMcpAppStyles() {
+    this.#refreshMcpAppHostContext();
+  }
   async scrollToBottom({ behavior } = {}) {
     await this._messageThreadRef.value?.updateComplete;
     await new Promise(requestAnimationFrame);
@@ -448,6 +581,7 @@ class AiChatbotBase extends LitElement {
     return this.agents.find((a) => a.id === this.selectedAgentId);
   }
   async setThreadState(threadState) {
+    this._teardownMcpAppViews();
     this.setMessages(threadState.messages);
     this.selectedAgentId = threadState.selectedAgentId;
     if (threadState.threadId && this._coreController.adapter) {
@@ -535,6 +669,16 @@ __decorateClass([
 __decorateClass([
   property({ attribute: false })
 ], AiChatbotBase.prototype, "contextItems");
+__decorateClass([
+  property({ attribute: "mcp-app-sandbox-url" })
+], AiChatbotBase.prototype, "mcpAppSandboxUrl");
+__decorateClass([
+  property({ attribute: "mcp-app-theme" })
+], AiChatbotBase.prototype, "mcpAppTheme");
+__decorateClass([
+  provide({ context: mcpAppHostContext }),
+  property({ attribute: false })
+], AiChatbotBase.prototype, "_mcpAppHost");
 export {
   AiChatbotBase
 };

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

@@ -1,5 +1,5 @@
 import { LitElement, TemplateResult, nothing, PropertyValues, CSSResult } from 'lit';
-import { ToolCall, ToolDefinition } from './types.js';
+import { ToolCall, AnyToolDefinition } from './types.js';
 declare global {
     interface HTMLElementTagNameMap {
         'forge-ai-chatbot-tool-call': AiChatbotToolCallComponent;
@@ -13,7 +13,7 @@ export declare class AiChatbotToolCallComponent extends LitElement {
     #private;
     static styles: CSSResult;
     toolCall: ToolCall;
-    toolDefinition?: ToolDefinition;
+    toolDefinition?: AnyToolDefinition;
     updated(changedProperties: PropertyValues<this>): void;
     render(): TemplateResult | typeof nothing;
 }