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

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

@@ -1,310 +0,0 @@
-import { ChatMessage, FileUploadCallbacks, McpAppUiResource, McpToolResult, AnyToolDefinition } 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: AnyToolDefinition[];
-    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: 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;
-    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;
-}

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

@@ -1,221 +0,0 @@
-import { EventEmitter } from "./event-emitter.mjs";
-class AgentAdapter {
-  constructor() {
-    this._state = { isConnected: false, isConnecting: false, isRunning: false };
-    this._tools = [];
-    this._events = {
-      runStarted: new EventEmitter(),
-      runFinished: new EventEmitter(),
-      runAborted: new EventEmitter(),
-      messageStart: new EventEmitter(),
-      messageDelta: new EventEmitter(),
-      messageEnd: new EventEmitter(),
-      toolCall: new EventEmitter(),
-      toolCallStart: new EventEmitter(),
-      toolCallArgs: new EventEmitter(),
-      toolCallEnd: new EventEmitter(),
-      toolResult: new EventEmitter(),
-      mcpUiResource: new EventEmitter(),
-      fileUpload: new EventEmitter(),
-      fileRemove: new EventEmitter(),
-      error: new EventEmitter(),
-      stateChange: new EventEmitter(),
-      customEvent: new EventEmitter(),
-      rawEvent: new EventEmitter(),
-      runStartedEvent: new EventEmitter(),
-      stepStarted: new EventEmitter(),
-      stepFinished: new EventEmitter(),
-      stateSnapshot: new EventEmitter(),
-      stateDelta: new EventEmitter(),
-      activitySnapshot: new EventEmitter(),
-      activityDelta: new EventEmitter()
-    };
-  }
-  setTools(tools) {
-    this._tools = tools;
-  }
-  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 };
-  }
-  get isConnected() {
-    return this._state.isConnected;
-  }
-  get isConnecting() {
-    return this._state.isConnecting;
-  }
-  get isRunning() {
-    return this._state.isRunning;
-  }
-  onRunStarted(callback) {
-    return this._events.runStarted.subscribe(callback);
-  }
-  onRunFinished(callback) {
-    return this._events.runFinished.subscribe(callback);
-  }
-  onRunAborted(callback) {
-    return this._events.runAborted.subscribe(callback);
-  }
-  onMessageStart(callback) {
-    return this._events.messageStart.subscribe(callback);
-  }
-  onMessageDelta(callback) {
-    return this._events.messageDelta.subscribe(callback);
-  }
-  onMessageEnd(callback) {
-    return this._events.messageEnd.subscribe(callback);
-  }
-  onToolCall(callback) {
-    return this._events.toolCall.subscribe(callback);
-  }
-  onToolCallStart(callback) {
-    return this._events.toolCallStart.subscribe(callback);
-  }
-  onToolCallArgs(callback) {
-    return this._events.toolCallArgs.subscribe(callback);
-  }
-  onToolCallEnd(callback) {
-    return this._events.toolCallEnd.subscribe(callback);
-  }
-  onToolCallResult(callback) {
-    return this._events.toolResult.subscribe(callback);
-  }
-  onMcpUiResource(callback) {
-    return this._events.mcpUiResource.subscribe(callback);
-  }
-  onFileUpload(callback) {
-    return this._events.fileUpload.subscribe(callback);
-  }
-  onFileRemove(callback) {
-    return this._events.fileRemove.subscribe(callback);
-  }
-  onError(callback) {
-    return this._events.error.subscribe(callback);
-  }
-  onStateChange(callback) {
-    return this._events.stateChange.subscribe(callback);
-  }
-  onCustomEvent(callback) {
-    return this._events.customEvent.subscribe(callback);
-  }
-  onRawEvent(callback) {
-    return this._events.rawEvent.subscribe(callback);
-  }
-  onRunStartedEvent(callback) {
-    return this._events.runStartedEvent.subscribe(callback);
-  }
-  onStepStarted(callback) {
-    return this._events.stepStarted.subscribe(callback);
-  }
-  onStepFinished(callback) {
-    return this._events.stepFinished.subscribe(callback);
-  }
-  onStateSnapshot(callback) {
-    return this._events.stateSnapshot.subscribe(callback);
-  }
-  onStateDelta(callback) {
-    return this._events.stateDelta.subscribe(callback);
-  }
-  onActivitySnapshot(callback) {
-    return this._events.activitySnapshot.subscribe(callback);
-  }
-  onActivityDelta(callback) {
-    return this._events.activityDelta.subscribe(callback);
-  }
-  _emitRunStarted() {
-    this._events.runStarted.emit();
-  }
-  _emitRunFinished() {
-    this._events.runFinished.emit();
-  }
-  _emitRunAborted() {
-    this._events.runAborted.emit();
-  }
-  _emitMessageStart(messageId, rawEvent) {
-    this._events.messageStart.emit({ messageId, rawEvent });
-  }
-  _emitMessageDelta(messageId, delta, rawEvent) {
-    this._events.messageDelta.emit({ messageId, delta, rawEvent });
-  }
-  _emitMessageEnd(messageId, rawEvent) {
-    this._events.messageEnd.emit({ messageId, rawEvent });
-  }
-  _emitToolCall(event, rawEvent) {
-    this._events.toolCall.emit({ ...event, rawEvent });
-  }
-  _emitToolCallStart(event, rawEvent) {
-    this._events.toolCallStart.emit({ ...event, rawEvent });
-  }
-  _emitToolCallArgs(event, rawEvent) {
-    this._events.toolCallArgs.emit({ ...event, rawEvent });
-  }
-  _emitToolCallEnd(event, rawEvent) {
-    this._events.toolCallEnd.emit({ ...event, rawEvent });
-  }
-  _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 });
-  }
-  emitFileRemove(fileId, callbacks) {
-    this._events.fileRemove.emit({ fileId, ...callbacks });
-  }
-  _emitError(message) {
-    this._events.error.emit({ message });
-  }
-  _emitCustomEvent(name, value, rawEvent) {
-    this._events.customEvent.emit({ name, value, rawEvent });
-  }
-  _emitRawEvent(event, rawEvent) {
-    this._events.rawEvent.emit({ event, rawEvent });
-  }
-  _emitRunStartedEvent(threadId, runId, rawEvent) {
-    this._events.runStartedEvent.emit({ threadId, runId, rawEvent });
-  }
-  _emitStepStarted(stepName, rawEvent) {
-    this._events.stepStarted.emit({ stepName, rawEvent });
-  }
-  _emitStepFinished(stepName, rawEvent) {
-    this._events.stepFinished.emit({ stepName, rawEvent });
-  }
-  _emitStateSnapshot(state, rawEvent) {
-    this._events.stateSnapshot.emit({ state, rawEvent });
-  }
-  _emitStateDelta(delta, rawEvent) {
-    this._events.stateDelta.emit({ delta, rawEvent });
-  }
-  _emitActivitySnapshot(activity, activityMessage, existingMessage, rawEvent) {
-    this._events.activitySnapshot.emit({ activity, activityMessage, existingMessage, rawEvent });
-  }
-  _emitActivityDelta(delta, activityMessage, rawEvent) {
-    this._events.activityDelta.emit({ delta, activityMessage, rawEvent });
-  }
-  _updateState(updates) {
-    this._state = { ...this._state, ...updates };
-    this._events.stateChange.emit(this.getState());
-  }
-}
-export {
-  AgentAdapter
-};

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

@@ -1,41 +0,0 @@
-import { AgentAdapter } from './agent-adapter.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?: 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 */
-    maxTurns?: number;
-    /** Callback fired when agent starts generating a new message */
-    onStart?: (messageId: string) => void;
-    /** Callback fired for each text chunk as it streams in */
-    onDelta?: (delta: string) => void;
-    /** Callback fired when agent requests a tool call */
-    onToolCall?: (toolCall: ToolCall) => void;
-    /** Callback fired when execution completes with final result */
-    onComplete?: (result: AgentRunnerResult) => void;
-}
-export interface AgentRunnerResult {
-    /** Complete message history including user, assistant, and tool messages */
-    messages: ChatMessage[];
-    /** The final assistant message returned by the agent */
-    finalMessage: ChatMessage;
-    /** All tool calls executed during the conversation */
-    toolCalls: ToolCall[];
-    /** Number of conversation turns completed */
-    turns: number;
-    /** Whether execution completed successfully without errors */
-    success: boolean;
-    /** Reason execution stopped: 'text-response' (natural completion), 'max-turns' (hit turn limit), 'error' (failed), or 'one-shot-complete' (single turn mode) */
-    stoppedReason: 'text-response' | 'max-turns' | 'error' | 'one-shot-complete';
-}
-export declare class AgentRunner {
-    #private;
-    private constructor();
-    static run(config: AgentRunnerConfig): Promise<AgentRunnerResult>;
-}