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

package/dist/ai-chatbot/ag-ui-adapter.mjs

@@ -1,388 +0,0 @@
-import { HttpAgentWithCredentials } from "./http-agent-with-credentials.mjs";
-import { AgentAdapter } from "./agent-adapter.mjs";
-import { generateId } from "./utils.mjs";
-class AgUiAdapter extends AgentAdapter {
-  #agent;
-  #toolCalls = /* @__PURE__ */ new Map();
-  #threadId;
-  #textBuffers = /* @__PURE__ */ new Map();
-  #context = {};
-  constructor(config, threadId) {
-    super();
-    this.#threadId = threadId ?? generateId();
-    this.#agent = new HttpAgentWithCredentials({
-      url: config.url,
-      headers: config.headers
-    });
-    this.#agent.threadId = this.#threadId;
-    if (config.tools) {
-      this.setTools(config.tools);
-    }
-    if (config.context) {
-      this.#context = { ...config.context };
-    }
-    this.#setupSubscriber();
-  }
-  get threadId() {
-    return this.#threadId;
-  }
-  set threadId(value) {
-    this.#threadId = value;
-    this.#agent.threadId = value;
-  }
-  setContext(context) {
-    this.#context = { ...context };
-  }
-  getContext() {
-    return { ...this.#context };
-  }
-  static async create(config) {
-    const { threadId, ...adapterConfig } = config;
-    const adapter = new AgUiAdapter(adapterConfig, threadId ?? generateId());
-    await adapter.connect();
-    return adapter;
-  }
-  async connect() {
-    if (this._state.isConnecting || this._state.isConnected) {
-      return;
-    }
-    this._updateState({ isConnecting: true, isConnected: true });
-    await Promise.resolve();
-    this._updateState({ isConnecting: false });
-  }
-  async disconnect() {
-    this.abort();
-    this._updateState({ isConnected: false });
-  }
-  sendMessage(messages) {
-    if (!this._state.isConnected) {
-      throw new Error("Adapter not connected. Call connect() first.");
-    }
-    const transformedMessages = this.#transformMessages(messages);
-    const context = Object.keys(this.#context).length ? this.#transformContext(this.#context) : void 0;
-    this.#agent.setMessages(transformedMessages);
-    const tools = this.#transformTools(this.getModelFacingTools());
-    this.#agent.runAgent({ tools, context });
-  }
-  sendToolResult(toolCallId, result, messages) {
-    const toolMessage = {
-      id: generateId(),
-      role: "tool",
-      content: JSON.stringify(result),
-      timestamp: Date.now(),
-      status: "complete",
-      toolCallId
-    };
-    messages = messages ? [...messages, toolMessage] : [toolMessage];
-    this.sendMessage(messages);
-    this._emitToolResult({ toolCallId, result, message: toolMessage });
-  }
-  abort() {
-    if (this._state.isRunning) {
-      try {
-        this.#agent.abortRun();
-      } catch {
-      }
-    }
-    this.#clearRunState();
-  }
-  #setupSubscriber() {
-    const subscriber = {
-      onRunInitialized: this.#handleRunInitialized.bind(this),
-      onTextMessageStartEvent: this.#handleTextMessageStart.bind(this),
-      onTextMessageContentEvent: this.#handleTextMessageContent.bind(this),
-      onTextMessageEndEvent: this.#handleTextMessageEnd.bind(this),
-      onToolCallStartEvent: this.#handleToolCallStart.bind(this),
-      onToolCallArgsEvent: this.#handleToolCallArgs.bind(this),
-      onToolCallEndEvent: this.#handleToolCallEnd.bind(this),
-      onToolCallResultEvent: this.#handleToolCallResult.bind(this),
-      onRunFinishedEvent: this.#handleRunFinished.bind(this),
-      onRunErrorEvent: this.#handleRunError.bind(this),
-      onRunFailed: this.#handleRunFailed.bind(this),
-      onCustomEvent: this.#handleCustomEvent.bind(this),
-      onRawEvent: this.#handleRawEvent.bind(this),
-      onRunStartedEvent: this.#handleRunStartedEvent.bind(this),
-      onStepStartedEvent: this.#handleStepStartedEvent.bind(this),
-      onStepFinishedEvent: this.#handleStepFinishedEvent.bind(this),
-      onStateSnapshotEvent: this.#handleStateSnapshotEvent.bind(this),
-      onStateDeltaEvent: this.#handleStateDeltaEvent.bind(this),
-      onActivitySnapshotEvent: this.#handleActivitySnapshotEvent.bind(this),
-      onActivityDeltaEvent: this.#handleActivityDeltaEvent.bind(this)
-    };
-    this.#agent.subscribe(subscriber);
-  }
-  #handleRunInitialized() {
-    this._updateState({ isRunning: true });
-    this._emitRunStarted();
-  }
-  #handleTextMessageStart({ event }) {
-    this._emitMessageStart(event.messageId, event);
-  }
-  #handleTextMessageContent({
-    textMessageBuffer,
-    event
-  }) {
-    this.#processTextDelta(event.messageId, textMessageBuffer);
-  }
-  #handleTextMessageEnd({
-    textMessageBuffer,
-    event
-  }) {
-    this.#processTextDelta(event.messageId, textMessageBuffer);
-    this._emitMessageEnd(event.messageId, event);
-  }
-  #handleToolCallStart({
-    event
-  }) {
-    const toolCallState = {
-      messageId: event.parentMessageId || "",
-      name: event.toolCallName,
-      argsBuffer: ""
-    };
-    this.#toolCalls.set(event.toolCallId, toolCallState);
-    this._emitToolCallStart(
-      {
-        id: event.toolCallId,
-        messageId: toolCallState.messageId,
-        name: toolCallState.name
-      },
-      event
-    );
-  }
-  #handleToolCallArgs({
-    event,
-    partialToolCallArgs,
-    toolCallBuffer
-  }) {
-    const toolCall = this.#getToolCallOrWarn(event.toolCallId);
-    if (!toolCall) {
-      return;
-    }
-    if (partialToolCallArgs && Object.keys(partialToolCallArgs).length) {
-      toolCall.argsBuffer = JSON.stringify(partialToolCallArgs);
-    } else {
-      toolCall.argsBuffer = toolCallBuffer;
-    }
-    this._emitToolCallArgs(
-      {
-        id: event.toolCallId,
-        messageId: toolCall.messageId,
-        name: toolCall.name,
-        argsBuffer: toolCall.argsBuffer,
-        partialArgs: partialToolCallArgs
-      },
-      event
-    );
-  }
-  #handleToolCallEnd({
-    event,
-    toolCallArgs
-  }) {
-    const toolCall = this.#getToolCallOrWarn(event.toolCallId);
-    if (!toolCall) {
-      return;
-    }
-    const args = toolCallArgs || {};
-    const toolDef = this.#findToolDefinition(toolCall.name);
-    if (toolDef) {
-      const validationError = this.#validateToolArgs(toolCall.name, args, toolDef);
-      if (validationError) {
-        this._emitError(validationError);
-        this.#toolCalls.delete(event.toolCallId);
-        return;
-      }
-    }
-    const toolCallEvent = {
-      id: event.toolCallId,
-      messageId: toolCall.messageId,
-      name: toolCall.name,
-      args
-    };
-    this._emitToolCallEnd(toolCallEvent, event);
-    this._emitToolCall(toolCallEvent, event);
-    this.#toolCalls.delete(event.toolCallId);
-  }
-  #handleToolCallResult({ event }) {
-    const result = JSON.parse(event.content);
-    const toolMessage = {
-      id: generateId(),
-      role: "tool",
-      content: event.content,
-      timestamp: Date.now(),
-      status: "complete",
-      toolCallId: event.toolCallId
-    };
-    this._emitToolResult(
-      {
-        toolCallId: event.toolCallId,
-        result,
-        message: toolMessage
-      },
-      event
-    );
-  }
-  #handleRunFinished() {
-    this.#clearRunState();
-    this._emitRunFinished();
-  }
-  #handleRunError({ event }) {
-    if (event.rawEvent?.name === "AbortError") {
-      this.#clearRunState();
-      this._emitRunAborted();
-      return;
-    }
-    this._emitError(event.message || "Unknown error");
-    this._updateState({ isRunning: false });
-  }
-  #handleRunFailed() {
-    this.#clearRunState();
-    this._emitError("An unexpected error occurred. Please try again.");
-  }
-  #handleCustomEvent({ event }) {
-    this._emitCustomEvent(event.name, event.value, event);
-  }
-  #handleRawEvent({ event }) {
-    this._emitRawEvent(event.event, event);
-  }
-  #handleRunStartedEvent({ event }) {
-    this._emitRunStartedEvent(event.threadId, event.runId, event);
-  }
-  #handleStepStartedEvent({ event }) {
-    this._emitStepStarted(event.stepName, event);
-  }
-  #handleStepFinishedEvent({ event }) {
-    this._emitStepFinished(event.stepName, event);
-  }
-  #handleStateSnapshotEvent({ event }) {
-    this._emitStateSnapshot(event.snapshot, event);
-  }
-  #handleStateDeltaEvent({ event }) {
-    this._emitStateDelta(event.delta, event);
-  }
-  #handleActivitySnapshotEvent({
-    event,
-    activityMessage,
-    existingMessage
-  }) {
-    this._emitActivitySnapshot(event.content, activityMessage, existingMessage, event);
-  }
-  #handleActivityDeltaEvent({
-    event,
-    activityMessage
-  }) {
-    this._emitActivityDelta(event.patch, activityMessage, event);
-  }
-  #processTextDelta(messageId, buffer) {
-    const previousBuffer = this.#textBuffers.get(messageId) ?? "";
-    const delta = buffer.slice(previousBuffer.length);
-    if (delta.length) {
-      this._emitMessageDelta(messageId, delta);
-    }
-    this.#textBuffers.set(messageId, buffer);
-  }
-  #getToolCallOrWarn(toolCallId) {
-    const toolCall = this.#toolCalls.get(toolCallId);
-    if (!toolCall) {
-      console.warn(`Tool call ${toolCallId} not found in state`);
-    }
-    return toolCall ?? null;
-  }
-  #findToolDefinition(name) {
-    return this._tools?.find((t) => t.name === name);
-  }
-  #clearRunState() {
-    this.#toolCalls.clear();
-    this.#textBuffers.clear();
-    this._updateState({ isRunning: false });
-  }
-  #transformTools(tools) {
-    if (!tools || tools.length === 0) {
-      return void 0;
-    }
-    return tools.map((tool) => {
-      const agUiTool = {
-        name: tool.name,
-        description: tool.description ?? "",
-        parameters: tool.parameters
-      };
-      return agUiTool;
-    });
-  }
-  #transformContext(context) {
-    return Object.entries(context).map(([key, value]) => ({
-      description: `Client context: ${key}`,
-      value: typeof value === "string" ? value : JSON.stringify(value)
-    }));
-  }
-  #transformMessages(messages) {
-    return messages.filter((msg) => msg.role === "user" || msg.role === "assistant" || msg.role === "system" || msg.role === "tool").filter((msg) => !msg.clientOnly).filter((msg) => {
-      if (msg.role === "assistant") {
-        const content = typeof msg.content === "string" ? msg.content : "";
-        return content.trim().length > 0 || msg.toolCalls && msg.toolCalls.length > 0;
-      }
-      return true;
-    }).map((msg) => {
-      switch (msg.role) {
-        case "user": {
-          const userMsg = {
-            id: msg.id,
-            role: "user",
-            content: msg.content
-          };
-          return userMsg;
-        }
-        case "assistant": {
-          const assistantMsg = {
-            id: msg.id,
-            role: "assistant",
-            content: msg.content || ""
-          };
-          if (msg.toolCalls && msg.toolCalls.length) {
-            assistantMsg.toolCalls = msg.toolCalls.map((tc) => ({
-              id: tc.id,
-              type: "function",
-              function: {
-                name: tc.name,
-                arguments: JSON.stringify(tc.args)
-              }
-            }));
-          }
-          return assistantMsg;
-        }
-        case "system": {
-          const systemMsg = {
-            id: msg.id,
-            role: "system",
-            content: msg.content
-          };
-          return systemMsg;
-        }
-        case "tool": {
-          const toolMsg = {
-            id: msg.id,
-            role: "tool",
-            toolCallId: msg.toolCallId || "",
-            content: msg.content
-          };
-          return toolMsg;
-        }
-      }
-    });
-  }
-  #validateToolArgs(toolName, args, toolDef) {
-    const { parameters } = toolDef;
-    if (!parameters || parameters.type !== "object") {
-      return null;
-    }
-    const required = parameters.required || [];
-    for (const field of required) {
-      if (!(field in args)) {
-        return `Tool ${toolName} missing required parameter: ${field}`;
-      }
-    }
-    return null;
-  }
-}
-export {
-  AgUiAdapter
-};

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

@@ -1,310 +0,0 @@
-import { ChatMessage, FileUploadCallbacks, McpAppUiResource, McpToolResult, ToolDefinition } from './types.js';
-import { EventEmitter, Subscription } from './event-emitter.js';
-export interface MessageStartEvent {
-    messageId: string;
-    rawEvent?: unknown;
-}
-export interface MessageDeltaEvent {
-    messageId: string;
-    delta: string;
-    rawEvent?: unknown;
-}
-export interface MessageEndEvent {
-    messageId: string;
-    rawEvent?: unknown;
-}
-export interface ToolCallEvent {
-    id: string;
-    messageId: string;
-    name: string;
-    args: Record<string, unknown>;
-    rawEvent?: unknown;
-}
-export interface ToolCallStartEvent {
-    id: string;
-    messageId: string;
-    name: string;
-    rawEvent?: unknown;
-}
-export interface ToolCallArgsEvent {
-    id: string;
-    messageId: string;
-    name: string;
-    /** Args text accumulated so far across this tool call's delta events. */
-    argsBuffer: string;
-    partialArgs?: Record<string, unknown>;
-    rawEvent?: unknown;
-}
-export interface ToolCallEndEvent {
-    id: string;
-    messageId: string;
-    name: string;
-    args: Record<string, unknown>;
-    rawEvent?: unknown;
-}
-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;
-    isRunning: boolean;
-}
-export interface FileUploadEvent extends FileUploadCallbacks {
-    file: File;
-}
-export interface FileRemoveEvent {
-    fileId: string;
-    onSuccess: () => void;
-    onError: (error: string) => void;
-}
-export interface ErrorEvent {
-    message: string;
-}
-export interface CustomAgentEvent {
-    name: string;
-    value: unknown;
-    rawEvent?: unknown;
-}
-export interface RawAgentEvent {
-    event: unknown;
-    rawEvent?: unknown;
-}
-export interface RunStartedAgentEvent {
-    threadId: string;
-    runId: string;
-    rawEvent?: unknown;
-}
-export interface StepStartedAgentEvent {
-    stepName: string;
-    rawEvent?: unknown;
-}
-export interface StepFinishedAgentEvent {
-    stepName: string;
-    rawEvent?: unknown;
-}
-export interface StateSnapshotAgentEvent {
-    state: unknown;
-    rawEvent?: unknown;
-}
-export interface StateDeltaAgentEvent {
-    delta: unknown[];
-    rawEvent?: unknown;
-}
-export interface ActivitySnapshotAgentEvent {
-    activity: unknown;
-    activityMessage?: unknown;
-    existingMessage?: unknown;
-    rawEvent?: unknown;
-}
-export interface ActivityDeltaAgentEvent {
-    delta: unknown;
-    activityMessage?: unknown;
-    rawEvent?: unknown;
-}
-export declare abstract class AgentAdapter {
-    protected _state: AdapterState;
-    protected _tools: ToolDefinition[];
-    protected _events: {
-        runStarted: EventEmitter<void>;
-        runFinished: EventEmitter<void>;
-        runAborted: EventEmitter<void>;
-        messageStart: EventEmitter<MessageStartEvent>;
-        messageDelta: EventEmitter<MessageDeltaEvent>;
-        messageEnd: EventEmitter<MessageEndEvent>;
-        toolCall: EventEmitter<ToolCallEvent>;
-        toolCallStart: EventEmitter<ToolCallStartEvent>;
-        toolCallArgs: EventEmitter<ToolCallArgsEvent>;
-        toolCallEnd: EventEmitter<ToolCallEndEvent>;
-        toolResult: EventEmitter<ToolResultEvent>;
-        mcpUiResource: EventEmitter<McpUiResourceEvent>;
-        fileUpload: EventEmitter<FileUploadEvent>;
-        fileRemove: EventEmitter<FileRemoveEvent>;
-        error: EventEmitter<ErrorEvent>;
-        stateChange: EventEmitter<AdapterState>;
-        customEvent: EventEmitter<CustomAgentEvent>;
-        rawEvent: EventEmitter<RawAgentEvent>;
-        runStartedEvent: EventEmitter<RunStartedAgentEvent>;
-        stepStarted: EventEmitter<StepStartedAgentEvent>;
-        stepFinished: EventEmitter<StepFinishedAgentEvent>;
-        stateSnapshot: EventEmitter<StateSnapshotAgentEvent>;
-        stateDelta: EventEmitter<StateDeltaAgentEvent>;
-        activitySnapshot: EventEmitter<ActivitySnapshotAgentEvent>;
-        activityDelta: EventEmitter<ActivityDeltaAgentEvent>;
-    };
-    abstract connect(): Promise<void>;
-    abstract disconnect(): Promise<void>;
-    abstract sendMessage(messages: ChatMessage[]): void;
-    abstract sendToolResult(toolCallId: string, result: unknown, messages: ChatMessage[]): void;
-    abstract abort(): void;
-    abstract get threadId(): string;
-    abstract set threadId(value: string);
-    clearMemory?(): Promise<void>;
-    /**
-     * 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: ToolDefinition[]): void;
-    getTools(): ToolDefinition[];
-    /**
-     * 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(): ToolDefinition[];
-    getState(): AdapterState;
-    get isConnected(): boolean;
-    get isConnecting(): boolean;
-    get isRunning(): boolean;
-    onRunStarted(callback: () => void): Subscription;
-    onRunFinished(callback: () => void): Subscription;
-    onRunAborted(callback: () => void): Subscription;
-    onMessageStart(callback: (event: MessageStartEvent) => void): Subscription;
-    onMessageDelta(callback: (event: MessageDeltaEvent) => void): Subscription;
-    onMessageEnd(callback: (event: MessageEndEvent) => void): Subscription;
-    onToolCall(callback: (event: ToolCallEvent) => void): Subscription;
-    onToolCallStart(callback: (event: ToolCallStartEvent) => void): Subscription;
-    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;
-    onStateChange(callback: (state: AdapterState) => void): Subscription;
-    onCustomEvent(callback: (event: CustomAgentEvent) => void): Subscription;
-    onRawEvent(callback: (event: RawAgentEvent) => void): Subscription;
-    onRunStartedEvent(callback: (event: RunStartedAgentEvent) => void): Subscription;
-    onStepStarted(callback: (event: StepStartedAgentEvent) => void): Subscription;
-    onStepFinished(callback: (event: StepFinishedAgentEvent) => void): Subscription;
-    onStateSnapshot(callback: (event: StateSnapshotAgentEvent) => void): Subscription;
-    onStateDelta(callback: (event: StateDeltaAgentEvent) => void): Subscription;
-    onActivitySnapshot(callback: (event: ActivitySnapshotAgentEvent) => void): Subscription;
-    onActivityDelta(callback: (event: ActivityDeltaAgentEvent) => void): Subscription;
-    protected _emitRunStarted(): void;
-    protected _emitRunFinished(): void;
-    protected _emitRunAborted(): void;
-    protected _emitMessageStart(messageId: string, rawEvent?: unknown): void;
-    protected _emitMessageDelta(messageId: string, delta: string, rawEvent?: unknown): void;
-    protected _emitMessageEnd(messageId: string, rawEvent?: unknown): void;
-    protected _emitToolCall(event: ToolCallEvent, rawEvent?: unknown): void;
-    protected _emitToolCallStart(event: ToolCallStartEvent, rawEvent?: unknown): void;
-    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;
-        onError: (error: string) => void;
-    }): void;
-    protected _emitError(message: string): void;
-    protected _emitCustomEvent(name: string, value: unknown, rawEvent?: unknown): void;
-    protected _emitRawEvent(event: unknown, rawEvent?: unknown): void;
-    protected _emitRunStartedEvent(threadId: string, runId: string, rawEvent?: unknown): void;
-    protected _emitStepStarted(stepName: string, rawEvent?: unknown): void;
-    protected _emitStepFinished(stepName: string, rawEvent?: unknown): void;
-    protected _emitStateSnapshot(state: unknown, rawEvent?: unknown): void;
-    protected _emitStateDelta(delta: unknown[], rawEvent?: unknown): void;
-    protected _emitActivitySnapshot(activity: unknown, activityMessage?: unknown, existingMessage?: unknown, rawEvent?: unknown): void;
-    protected _emitActivityDelta(delta: unknown, activityMessage?: unknown, rawEvent?: unknown): void;
-    protected _updateState(updates: Partial<AdapterState>): void;
-}