@assistant-ui/core 0.1.17 → 0.2.2

package/src/runtime/api/thread-list-runtime.ts

@@ -28,6 +28,8 @@ export type ThreadListState = {
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];
   readonly isLoading: boolean;
+  readonly isLoadingMore: boolean;
+  readonly hasMore: boolean;
   readonly threadItems: Readonly<
     Record<string, Omit<ThreadListItemState, "isMain" | "threadId">>
   >;
@@ -51,6 +53,7 @@ export type ThreadListRuntime = {
 
   getLoadThreadsPromise(): Promise<void>;
   reload(): Promise<void>;
+  loadMore(): Promise<void>;
 };
 
 const getThreadListState = (
@@ -62,6 +65,8 @@ const getThreadListState = (
     threadIds: threadList.threadIds,
     archivedThreadIds: threadList.archivedThreadIds,
     isLoading: threadList.isLoading,
+    isLoadingMore: threadList.isLoadingMore ?? false,
+    hasMore: threadList.hasMore ?? false,
     threadItems: threadList.threadItems,
   };
 };
@@ -138,6 +143,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     this.switchToNewThread = this.switchToNewThread.bind(this);
     this.getLoadThreadsPromise = this.getLoadThreadsPromise.bind(this);
     this.reload = this.reload.bind(this);
+    this.loadMore = this.loadMore.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
     this.getById = this.getById.bind(this);
@@ -162,6 +168,10 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     return this._core.reload?.() ?? RESOLVED_PROMISE;
   }
 
+  public loadMore(): Promise<void> {
+    return this._core.loadMore?.() ?? RESOLVED_PROMISE;
+  }
+
   public getState(): ThreadListState {
     return this._getState();
   }

package/src/runtime/api/thread-runtime.ts

@@ -252,10 +252,6 @@ export type ThreadRuntime = {
    */
   append(message: CreateAppendMessage): void;
 
-  /**
-   * @deprecated pass an object with `parentId` instead. This will be removed in 0.12.0.
-   */
-  startRun(parentId: string | null): void;
   /**
    * Start a new run with the given configuration.
    * @param config The configuration for starting the run
@@ -268,11 +264,6 @@ export type ThreadRuntime = {
    **/
   resumeRun(config: CreateResumeRunConfig): void;
 
-  /**
-   * @deprecated Use `resumeRun` instead.
-   */
-  unstable_resumeRun(config: CreateResumeRunConfig): void;
-
   /**
    * Export the thread state in the external store format.
    * For AI SDK runtimes, this returns the AI SDK message format.
@@ -289,22 +280,10 @@ export type ThreadRuntime = {
    */
   importExternalState(state: any): void;
 
-  /**
-   * Load external state into the thread.
-   * @deprecated Use importExternalState instead. This method will be removed in 0.12.0.
-   * @param state The state to load into the thread
-   */
-  unstable_loadExternalState(state: any): void;
-
   subscribe(callback: () => void): Unsubscribe;
   cancelRun(): void;
   getModelContext(): ModelContext;
 
-  /**
-   * @deprecated This method was renamed to `getModelContext`.
-   */
-  getModelConfig(): ModelContext;
-
   export(): ExportedMessageRepository;
   import(repository: ExportedMessageRepository): void;
 
@@ -396,9 +375,6 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
   protected __internal_bindMethods() {
     this.append = this.append.bind(this);
     this.resumeRun = this.resumeRun.bind(this);
-    this.unstable_resumeRun = this.unstable_resumeRun.bind(this);
-    this.unstable_loadExternalState =
-      this.unstable_loadExternalState.bind(this);
     this.importExternalState = this.importExternalState.bind(this);
     this.exportExternalState = this.exportExternalState.bind(this);
     this.startRun = this.startRun.bind(this);
@@ -418,7 +394,6 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     this.subscribe = this.subscribe.bind(this);
     this.unstable_on = this.unstable_on.bind(this);
     this.getModelContext = this.getModelContext.bind(this);
-    this.getModelConfig = this.getModelConfig.bind(this);
     this.getState = this.getState.bind(this);
   }
 
@@ -444,15 +419,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     return this._threadBinding.getState().getModelContext();
   }
 
-  public getModelConfig() {
-    return this.getModelContext();
-  }
-
-  public startRun(configOrParentId: string | null | CreateStartRunConfig) {
-    const config =
-      configOrParentId === null || typeof configOrParentId === "string"
-        ? { parentId: configOrParentId }
-        : configOrParentId;
+  public startRun(config: CreateStartRunConfig) {
     return this._threadBinding.getState().startRun(toStartRunConfig(config));
   }
 
@@ -460,11 +427,6 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     return this._threadBinding.getState().resumeRun(toResumeRunConfig(config));
   }
 
-  /** @deprecated Use `resumeRun` instead. */
-  public unstable_resumeRun(config: CreateResumeRunConfig) {
-    return this.resumeRun(config);
-  }
-
   public exportExternalState() {
     return this._threadBinding.getState().exportExternalState();
   }
@@ -473,10 +435,6 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     this._threadBinding.getState().importExternalState(state);
   }
 
-  public unstable_loadExternalState(state: any) {
-    this._threadBinding.getState().unstable_loadExternalState(state);
-  }
-
   public cancelRun() {
     this._threadBinding.getState().cancelRun();
   }
@@ -575,7 +533,6 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
           const thread = this._threadBinding.getState();
 
           const branches = thread.getBranches(message.id);
-          const submittedFeedback = message.metadata.submittedFeedback;
 
           return {
             ...message,
@@ -590,8 +547,6 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
 
             speech:
               speechState?.messageId === message.id ? speechState : undefined,
-
-            submittedFeedback,
           } satisfies MessageState;
         },
         subscribe: (callback) => this._threadBinding.subscribe(callback),

package/src/runtime/base/base-composer-runtime-core.ts

@@ -52,6 +52,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public abstract get canCancel(): boolean;
+  public abstract get canSend(): boolean;
 
   public get isEmpty() {
     return !this.text.trim() && !this.attachments.length;
@@ -157,7 +158,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async send(options?: SendOptions) {
-    if (this.isEmpty) return;
+    if (!this.canSend) return;
 
     if (this._dictationSession) {
       this._dictationSession.cancel();

package/src/runtime/base/base-thread-runtime-core.ts

@@ -48,6 +48,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   protected readonly repository = new MessageRepository();
   public abstract get adapters(): BaseThreadAdapters | undefined;
   public abstract get isDisabled(): boolean;
+  public abstract get isSendDisabled(): boolean;
   public abstract get isLoading(): boolean;
   public abstract get suggestions(): readonly ThreadSuggestion[];
   public abstract get extras(): unknown;
@@ -61,7 +62,6 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   public abstract cancelRun(): void;
   public abstract exportExternalState(): any;
   public abstract importExternalState(state: any): void;
-  public abstract unstable_loadExternalState(state: any): void;
 
   protected _voiceMessages: ThreadMessage[] = [];
   protected _voiceGeneration = 0;

package/src/runtime/base/default-edit-composer-runtime-core.ts

@@ -13,6 +13,10 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
     return true;
   }
 
+  public get canSend() {
+    return !this.isEmpty;
+  }
+
   protected getAttachmentAdapter() {
     return this.runtime.adapters?.attachments;
   }

package/src/runtime/base/default-thread-composer-runtime-core.ts

@@ -17,6 +17,10 @@ export class DefaultThreadComposerRuntimeCore
     return this._canCancel;
   }
 
+  public get canSend() {
+    return !this.isEmpty && !this.runtime.isSendDisabled;
+  }
+
   protected getAttachmentAdapter() {
     return this.runtime.adapters?.attachments;
   }
@@ -40,11 +44,18 @@ export class DefaultThreadComposerRuntimeCore
   }
 
   public connect() {
+    let lastIsSendDisabled = this.runtime.isSendDisabled;
     return this.runtime.subscribe(() => {
+      let changed = false;
       if (this.canCancel !== this.runtime.capabilities.cancel) {
         this._canCancel = this.runtime.capabilities.cancel;
-        this._notifySubscribers();
+        changed = true;
+      }
+      if (lastIsSendDisabled !== this.runtime.isSendDisabled) {
+        lastIsSendDisabled = this.runtime.isSendDisabled;
+        changed = true;
       }
+      if (changed) this._notifySubscribers();
     });
   }
 

package/src/runtime/interfaces/composer-runtime-core.ts

@@ -51,6 +51,7 @@ export type ComposerRuntimeCore = Readonly<{
   isEditing: boolean;
 
   canCancel: boolean;
+  canSend: boolean;
   isEmpty: boolean;
 
   attachments: readonly Attachment[];

package/src/runtime/interfaces/thread-list-runtime-core.ts

@@ -17,6 +17,8 @@ export type ThreadListItemCoreState = {
 
 export type ThreadListRuntimeCore = {
   readonly isLoading: boolean;
+  readonly isLoadingMore?: boolean;
+  readonly hasMore?: boolean;
   mainThreadId: string;
   newThreadId: string | undefined;
 
@@ -35,6 +37,7 @@ export type ThreadListRuntimeCore = {
 
   getLoadThreadsPromise(): Promise<void>;
   reload?(): Promise<void>;
+  loadMore?(): Promise<void>;
 
   detach(threadId: string): Promise<void>;
   rename(threadId: string, newTitle: string): Promise<void>;

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -158,6 +158,12 @@ export type ThreadRuntimeCore = Readonly<{
 
   capabilities: Readonly<RuntimeCapabilities>;
   isDisabled: boolean;
+  /**
+   * Whether sending from this thread's composer is disabled. Surfaces the
+   * `isSendDisabled` flag from external-store adapters; internal runtimes
+   * default to `false`. Composer state derives `canSend` from this.
+   */
+  isSendDisabled: boolean;
   isLoading: boolean;
   /**
    * Optional explicit thread-level running flag. When provided, takes
@@ -194,9 +200,4 @@ export type ThreadRuntimeCore = Readonly<{
     event: E,
     callback: ThreadRuntimeEventCallback<E>,
   ): Unsubscribe;
-
-  /**
-   * @deprecated Use importExternalState instead. This method will be removed in 0.12.0.
-   */
-  unstable_loadExternalState: (state: any) => void;
 }>;

package/src/runtime/utils/chat-model-adapter.ts

@@ -50,11 +50,6 @@ export type ChatModelRunOptions = {
   readonly abortSignal: AbortSignal;
   readonly context: ModelContext;
 
-  /**
-   * @deprecated This field was renamed to `context`.
-   */
-  readonly config: ModelContext;
-
   readonly unstable_assistantMessageId?: string | undefined;
   readonly unstable_threadId?: string | undefined;
   readonly unstable_parentId?: string | null | undefined;

package/src/runtime/utils/external-store-message.ts

@@ -8,14 +8,6 @@ type WithInnerMessages<T> = {
   [symbolInnerMessages]?: T[];
 };
 
-/**
- * @deprecated Use `getExternalStoreMessages` (plural) instead. This function will be removed in 0.12.0.
- */
-export const getExternalStoreMessage = <T>(input: ThreadMessage) => {
-  const withInnerMessages = input as WithInnerMessages<T>;
-  return withInnerMessages[symbolInnerMessage];
-};
-
 const EMPTY_ARRAY: never[] = [];
 
 /**

package/src/runtimes/assistant-transport/utils.ts

@@ -1,31 +1,3 @@
-import {
-  type Tool,
-  toToolsJSONSchema,
-  type ToolJSONSchema,
-} from "assistant-stream";
-
-/**
- * @deprecated Use `toToolsJSONSchema` from `assistant-stream` instead.
- */
-export function toAISDKTools(
-  tools: Record<string, Tool>,
-): Record<string, ToolJSONSchema> {
-  return toToolsJSONSchema(tools, { filter: () => true });
-}
-
-/**
- * @deprecated Use `toToolsJSONSchema` from `assistant-stream` instead, which includes filtering by default.
- */
-export function getEnabledTools(
-  tools: Record<string, Tool>,
-): Record<string, Tool> {
-  return Object.fromEntries(
-    Object.entries(tools).filter(
-      ([, tool]) => !tool.disabled && tool.type !== "backend",
-    ),
-  );
-}
-
 export async function createRequestHeaders(
   headersValue:
     | Record<string, string>

package/src/runtimes/external-store/external-store-adapter.ts

@@ -59,7 +59,22 @@ type ExternalStoreMessageConverterAdapter<T> = {
 };
 
 type ExternalStoreAdapterBase<T> = {
+  /**
+   * Whether the entire thread is disabled. When `true`, the composer's input
+   * is also disabled (the user cannot type, attach files, or submit). For a
+   * narrower gate that keeps the input usable but blocks only sending, use
+   * `isSendDisabled`.
+   */
   isDisabled?: boolean | undefined;
+  /**
+   * Whether sending new messages is currently disabled. When `true`, the
+   * thread composer's input remains usable but `send()` becomes a no-op
+   * and the thread composer's `canSend` is `false`. Use this to gate
+   * sending on external React state (e.g. while tool config is loading)
+   * without disabling the input itself the way `isDisabled` does. Edit
+   * composers (saving message edits) intentionally ignore this flag.
+   */
+  isSendDisabled?: boolean | undefined;
   /**
    * Whether the thread is running. When provided, this value flows directly
    * to `thread.isRunning`, letting the application keep the thread in a

package/src/runtimes/external-store/external-store-thread-list-runtime-core.ts

@@ -78,14 +78,7 @@ export class ExternalStoreThreadListRuntimeCore
   }
 
   public getItemById(threadId: string) {
-    for (const thread of this.adapter.threads ?? []) {
-      if (thread.id === threadId) return thread as any;
-    }
-    for (const thread of this.adapter.archivedThreads ?? []) {
-      if (thread.id === threadId) return thread as any;
-    }
-    if (threadId === DEFAULT_THREAD_ID) return DEFAULT_THREAD;
-    return undefined;
+    return this._threadData[threadId];
   }
 
   public __internal_setAdapter(
@@ -115,7 +108,8 @@ export class ExternalStoreThreadListRuntimeCore
 
     if (
       previousThreads !== newThreads ||
-      previousArchivedThreads !== newArchivedThreads
+      previousArchivedThreads !== newArchivedThreads ||
+      previousThreadId !== newThreadId
     ) {
       this._threadData = {
         ...DEFAULT_THREAD_DATA,
@@ -159,6 +153,18 @@ export class ExternalStoreThreadListRuntimeCore
       this._mainThread = this.threadFactory();
     }
 
+    if (!this._threadData[this._mainThreadId]) {
+      this._threadData = {
+        ...this._threadData,
+        [this._mainThreadId]: {
+          id: this._mainThreadId,
+          remoteId: undefined,
+          externalId: undefined,
+          status: "regular",
+        },
+      };
+    }
+
     this._notifySubscribers();
   }
 

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -75,6 +75,7 @@ export class ExternalStoreThreadRuntimeCore
 
   private _messages!: readonly ThreadMessage[];
   public isDisabled!: boolean;
+  public isSendDisabled!: boolean;
   public get isLoading() {
     return this._store.isLoading ?? false;
   }
@@ -122,6 +123,7 @@ export class ExternalStoreThreadRuntimeCore
 
     const isRunning = store.isRunning ?? false;
     this.isDisabled = store.isDisabled ?? false;
+    this.isSendDisabled = store.isSendDisabled ?? false;
 
     const oldStore = this._store as ExternalStoreAdapter<any> | undefined;
     this._store = store;
@@ -316,10 +318,6 @@ export class ExternalStoreThreadRuntimeCore
     this._store.onLoadExternalState(state);
   }
 
-  public unstable_loadExternalState(state: any): void {
-    this.importExternalState(state);
-  }
-
   public cancelRun(): void {
     if (!this._store.onCancel)
       throw new Error("Runtime does not support cancelling runs.");

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -54,6 +54,7 @@ export class LocalThreadRuntimeCore
   private abortController: AbortController | null = null;
 
   public readonly isDisabled = false;
+  public readonly isSendDisabled = false;
 
   private _isLoading = false;
   public get isLoading() {
@@ -226,10 +227,6 @@ export class LocalThreadRuntimeCore
     throw new Error("Runtime does not support importing external states.");
   }
 
-  public unstable_loadExternalState(): void {
-    throw new Error("Runtime does not support importing external states.");
-  }
-
   public async startRun(
     { parentId, runConfig }: StartRunConfig,
     runCallback?: ChatModelAdapter["run"],
@@ -405,7 +402,6 @@ export class LocalThreadRuntimeCore
         runConfig: this._lastRunConfig,
         abortSignal,
         context,
-        config: context,
         unstable_assistantMessageId: message.id,
         unstable_threadId: threadId,
         unstable_parentId: parentId,

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -104,10 +104,6 @@ export class ReadonlyThreadRuntimeCore
     throw READONLY_THREAD_ERROR;
   }
 
-  unstable_loadExternalState(): void {
-    throw READONLY_THREAD_ERROR;
-  }
-
   composer = {
     attachments: [] as never[],
     attachmentAccept: "*",
@@ -122,6 +118,7 @@ export class ReadonlyThreadRuntimeCore
 
     isEditing: false as const,
     canCancel: false,
+    canSend: false,
     isEmpty: true,
     text: "",
 
@@ -209,6 +206,7 @@ export class ReadonlyThreadRuntimeCore
   } as const;
 
   isDisabled = false;
+  isSendDisabled = false;
   isLoading = false;
 
   state = null;

package/src/runtimes/remote-thread-list/empty-thread-core.ts

@@ -83,10 +83,6 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     throw EMPTY_THREAD_ERROR;
   },
 
-  unstable_loadExternalState() {
-    throw EMPTY_THREAD_ERROR;
-  },
-
   composer: {
     attachments: [],
     attachmentAccept: "*",
@@ -102,6 +98,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     isEditing: true,
 
     canCancel: false,
+    canSend: false,
     isEmpty: true,
 
     text: "",
@@ -190,6 +187,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
   },
 
   isDisabled: false,
+  isSendDisabled: false,
   isLoading: true,
 
   messages: [],

package/src/runtimes/remote-thread-list/remote-thread-state.ts

@@ -1,4 +1,7 @@
-import type { RemoteThreadInitializeResponse } from "./types";
+import type {
+  RemoteThreadInitializeResponse,
+  RemoteThreadMetadata,
+} from "./types";
 
 export type RemoteThreadData =
   | {
@@ -34,8 +37,58 @@ export function createThreadMappingId(id: string): THREAD_MAPPING_ID {
   return id as THREAD_MAPPING_ID;
 }
 
+export const normalizeCursor = (c: string | undefined): string | undefined =>
+  c || undefined;
+
+type ClassifyAccumulator = {
+  threadIds: string[];
+  archivedThreadIds: string[];
+  threadIdMap: Record<string, THREAD_MAPPING_ID>;
+  threadData: Record<THREAD_MAPPING_ID, RemoteThreadData>;
+};
+
+export const classifyThreads = (
+  threads: readonly RemoteThreadMetadata[],
+  acc: ClassifyAccumulator,
+): ClassifyAccumulator => {
+  for (const thread of threads) {
+    if (acc.threadIdMap[thread.remoteId] !== undefined) continue;
+
+    switch (thread.status) {
+      case "regular":
+        acc.threadIds.push(thread.remoteId);
+        break;
+      case "archived":
+        acc.archivedThreadIds.push(thread.remoteId);
+        break;
+      default: {
+        const _exhaustiveCheck: never = thread.status;
+        throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+      }
+    }
+
+    const mappingId = createThreadMappingId(thread.remoteId);
+    acc.threadIdMap[thread.remoteId] = mappingId;
+    acc.threadData[mappingId] = {
+      id: thread.remoteId,
+      remoteId: thread.remoteId,
+      externalId: thread.externalId,
+      status: thread.status,
+      title: thread.title,
+      custom: thread.custom,
+      initializeTask: Promise.resolve({
+        remoteId: thread.remoteId,
+        externalId: thread.externalId,
+      }),
+    };
+  }
+  return acc;
+};
+
 export type RemoteThreadState = {
   readonly isLoading: boolean;
+  readonly isLoadingMore: boolean;
+  readonly cursor: string | undefined;
   readonly newThreadId: string | undefined;
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];

package/src/runtimes/remote-thread-list/types.ts

@@ -18,10 +18,15 @@ export type RemoteThreadMetadata = {
 
 export type RemoteThreadListResponse = {
   threads: RemoteThreadMetadata[];
+  nextCursor?: string | undefined;
+};
+
+export type RemoteThreadListPageOptions = {
+  after?: string | undefined;
 };
 
 export type RemoteThreadListAdapter = {
-  list(): Promise<RemoteThreadListResponse>;
+  list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
 
   rename(remoteId: string, newTitle: string): Promise<void>;
   archive(remoteId: string): Promise<void>;

package/src/store/clients/no-op-composer-client.ts

@@ -14,6 +14,7 @@ export const NoOpComposerClient = resource(
         role: "user",
         runConfig: {},
         canCancel: false,
+        canSend: false,
         type: type,
         dictation: undefined,
         quote: undefined,

package/src/store/clients/thread-message-client.ts

@@ -106,7 +106,6 @@ export const ThreadMessageClient = resource(
         branchNumber,
         branchCount,
         speech: undefined,
-        submittedFeedback: message.metadata.submittedFeedback,
         isCopied: isCopiedState,
         isHovering: isHoveringState,
       };

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -103,6 +103,7 @@ export const ComposerClient = resource(
         runConfig: runtimeState.runConfig,
         isEditing: runtimeState.isEditing,
         canCancel: runtimeState.canCancel,
+        canSend: runtimeState.canSend,
         attachmentAccept: runtimeState.attachmentAccept,
         isEmpty: runtimeState.isEmpty,
         type: runtimeState.type ?? "thread",

package/src/store/runtime-clients/thread-list-runtime-client.ts

@@ -53,6 +53,8 @@ export const ThreadListClient = resource(
         mainThreadId: runtimeState.mainThreadId,
         newThreadId: runtimeState.newThreadId ?? null,
         isLoading: runtimeState.isLoading,
+        isLoadingMore: runtimeState.isLoadingMore,
+        hasMore: runtimeState.hasMore,
         threadIds: runtimeState.threadIds,
         archivedThreadIds: runtimeState.archivedThreadIds,
         threadItems: threadItems.state,
@@ -87,6 +89,7 @@ export const ThreadListClient = resource(
       },
       getLoadThreadsPromise: () => runtime.getLoadThreadsPromise(),
       reload: () => runtime.reload(),
+      loadMore: () => runtime.loadMore(),
       __internal_getAssistantRuntime: () => __internal_assistantRuntime,
     };
   },

package/src/store/runtime-clients/thread-runtime-client.ts

@@ -116,7 +116,6 @@ export const ThreadClient = resource(
       append: runtime.append,
       startRun: runtime.startRun,
       resumeRun: runtime.resumeRun,
-      unstable_resumeRun: runtime.resumeRun,
       cancelRun: runtime.cancelRun,
       getModelContext: runtime.getModelContext,
       export: runtime.export,