@assistant-ui/react 0.7.58 → 0.7.59

package/src/cloud/auiV0.ts

@@ -0,0 +1,130 @@
+import { JSONObject } from "@ai-sdk/provider";
+import { ThreadMessage } from "../types";
+import { MessageStatus } from "../types/AssistantTypes";
+import { fromThreadMessageLike } from "../runtimes/external-store/ThreadMessageLike";
+import { CloudMessage } from "./AssistantCloudThreadMessages";
+import { isJSONValue } from "../utils/json/is-json";
+import { ReadonlyJSONValue } from "../utils/json/json-value";
+import { ExportedMessageRepositoryItem } from "../runtimes/utils/MessageRepository";
+
+type AuiV0MessageContentPart =
+  | {
+      readonly type: "text";
+      readonly text: string;
+    }
+  | {
+      readonly type: "tool-call";
+      readonly toolCallId: string;
+      readonly toolName: string;
+      readonly args: ReadonlyJSONValue;
+      readonly result?: ReadonlyJSONValue;
+      readonly isError?: true;
+    }
+  | {
+      readonly type: "tool-call";
+      readonly toolCallId: string;
+      readonly toolName: string;
+      readonly argsText: string;
+      readonly result?: ReadonlyJSONValue;
+      readonly isError?: true;
+    };
+
+type AuiV0Message = {
+  readonly role: "assistant" | "user" | "system";
+  readonly status?: MessageStatus;
+  readonly content: readonly AuiV0MessageContentPart[];
+  readonly metadata: {
+    readonly unstable_annotations: readonly ReadonlyJSONValue[];
+    readonly unstable_data: readonly ReadonlyJSONValue[];
+    readonly steps: readonly {
+      readonly usage?: {
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+      };
+    }[];
+    readonly custom: Readonly<JSONObject>;
+  };
+};
+
+export const auiV0Encode = (message: ThreadMessage): AuiV0Message => {
+  // TODO attachments are currently intentionally ignored
+  // info: ID and createdAt are ignored (we use the server value instead)
+  return {
+    role: message.role,
+    content: message.content.map((part) => {
+      const type = part.type;
+      switch (type) {
+        case "text": {
+          return {
+            type: "text",
+            text: part.text,
+          };
+        }
+
+        case "tool-call": {
+          if (!isJSONValue(part.result)) {
+            console.warn(
+              "tool-call result is not JSON! " + JSON.stringify(part),
+            );
+          }
+          return {
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            ...(JSON.stringify(part.args) === part.argsText
+              ? {
+                  args: part.args,
+                }
+              : { argsText: part.argsText }),
+            ...(part.result
+              ? { result: part.result as ReadonlyJSONValue }
+              : {}),
+            ...(part.isError ? { isError: true } : {}),
+          };
+        }
+
+        default: {
+          const unhandledType: "ui" | "image" | "file" | "audio" = type;
+          throw new Error(
+            `Content part type not supported by aui/v0: ${unhandledType}`,
+          );
+        }
+      }
+    }),
+    metadata: message.metadata as AuiV0Message["metadata"],
+    ...(message.status
+      ? {
+          status:
+            message.status?.type === "running"
+              ? {
+                  type: "incomplete",
+                  reason: "cancelled",
+                }
+              : message.status,
+        }
+      : undefined),
+  };
+};
+
+export const auiV0Decode = (
+  cloudMessage: CloudMessage & { format: "aui/v0" },
+): ExportedMessageRepositoryItem => {
+  const payload = cloudMessage.content as unknown as AuiV0Message;
+  const message = fromThreadMessageLike(
+    {
+      id: cloudMessage.id,
+      createdAt: cloudMessage.created_at,
+      ...payload,
+    },
+    cloudMessage.id,
+    {
+      type: "complete",
+      reason: "unknown",
+    },
+  );
+
+  return {
+    parentId: cloudMessage.parent_id,
+    message,
+  };
+};

package/src/{runtimes/remote-thread-list/cloud → cloud}/useCloudThreadListRuntime.tsx

@@ -1,11 +1,21 @@
 "use client";
 
-import { useEffect, useRef, useState } from "react";
-import { useRemoteThreadListRuntime } from "../useRemoteThreadListRuntime";
+import {
+  FC,
+  PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { AssistantCloud } from "./AssistantCloud";
-import { AssistantRuntime } from "../../../api";
-import { RemoteThreadListSubscriber } from "../types";
-import { toCoreMessages } from "../../edge";
+import { AssistantRuntime } from "../api";
+import { RemoteThreadListSubscriber } from "../runtimes/remote-thread-list/types";
+import { toCoreMessages } from "../runtimes/edge";
+import { useRemoteThreadListRuntime } from "../runtimes/remote-thread-list/useRemoteThreadListRuntime";
+import { RuntimeAdapterProvider } from "../runtimes/adapters/RuntimeAdapterProvider";
+import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 
 type ThreadData = {
   externalId: string;
@@ -104,6 +114,20 @@ export const useCloudThreadListRuntime = (adapter: CloudThreadListAdapter) => {
         subscribers.delete(callback);
       };
     },
+    unstable_Provider: useCallback<FC<PropsWithChildren>>(({ children }) => {
+      const history = useAssistantCloudThreadHistoryAdapter({
+        get current() {
+          return adapterRef.current.cloud;
+        },
+      });
+      const adapters = useMemo(() => ({ history }), [history]);
+
+      return (
+        <RuntimeAdapterProvider adapters={adapters}>
+          {children}
+        </RuntimeAdapterProvider>
+      );
+    }, []),
   });
 
   return runtime;

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./api";
+export * from "./cloud";
 export * from "./context";
 export * from "./model-context";
 export * from "./primitives";

package/src/model-context/makeAssistantTool.tsx

@@ -2,15 +2,13 @@
 
 import { FC } from "react";
 import { type AssistantToolProps, useAssistantTool } from "./useAssistantTool";
+import { ReadonlyJSONObject } from "../utils/json/json-value";
 
 export type AssistantTool = FC & {
   unstable_tool: AssistantToolProps<any, any>;
 };
 
-export const makeAssistantTool = <
-  TArgs extends Record<string, unknown>,
-  TResult,
->(
+export const makeAssistantTool = <TArgs extends ReadonlyJSONObject, TResult>(
   tool: AssistantToolProps<TArgs, TResult>,
 ) => {
   const Tool: AssistantTool = () => {

package/src/model-context/makeAssistantToolUI.tsx

@@ -5,15 +5,13 @@ import {
   type AssistantToolUIProps,
   useAssistantToolUI,
 } from "./useAssistantToolUI";
+import { ReadonlyJSONObject } from "../utils/json/json-value";
 
 export type AssistantToolUI = FC & {
   unstable_tool: AssistantToolUIProps<any, any>;
 };
 
-export const makeAssistantToolUI = <
-  TArgs extends Record<string, unknown>,
-  TResult,
->(
+export const makeAssistantToolUI = <TArgs extends ReadonlyJSONObject, TResult>(
   tool: AssistantToolUIProps<TArgs, TResult>,
 ) => {
   const ToolUI: AssistantToolUI = () => {

package/src/model-context/useAssistantTool.tsx

@@ -7,9 +7,10 @@ import {
 } from "../context/react/AssistantContext";
 import type { ToolCallContentPartComponent } from "../types/ContentPartComponentTypes";
 import type { Tool } from "./ModelContextTypes";
+import { ReadonlyJSONObject } from "../utils/json/json-value";
 
 export type AssistantToolProps<
-  TArgs extends Record<string, unknown>,
+  TArgs extends ReadonlyJSONObject,
   TResult,
 > = Tool<TArgs, TResult> & {
   toolName: string;
@@ -17,10 +18,7 @@ export type AssistantToolProps<
   disabled?: boolean | undefined;
 };
 
-export const useAssistantTool = <
-  TArgs extends Record<string, unknown>,
-  TResult,
->(
+export const useAssistantTool = <TArgs extends ReadonlyJSONObject, TResult>(
   tool: AssistantToolProps<TArgs, TResult>,
 ) => {
   const assistantRuntime = useAssistantRuntime();

package/src/model-context/useAssistantToolUI.tsx

@@ -3,11 +3,9 @@
 import { useEffect } from "react";
 import { useToolUIsStore } from "../context/react/AssistantContext";
 import type { ToolCallContentPartComponent } from "../types/ContentPartComponentTypes";
+import { ReadonlyJSONObject } from "../utils/json/json-value";
 
-export type AssistantToolUIProps<
-  TArgs extends Record<string, unknown>,
-  TResult,
-> = {
+export type AssistantToolUIProps<TArgs extends ReadonlyJSONObject, TResult> = {
   toolName: string;
   render: ToolCallContentPartComponent<TArgs, TResult>;
 };

package/src/model-context/useInlineRender.tsx

@@ -3,8 +3,9 @@
 import { FC, useCallback, useEffect, useState } from "react";
 import { ToolCallContentPartProps } from "../types";
 import { create } from "zustand";
+import { ReadonlyJSONObject } from "../utils/json/json-value";
 
-export const useInlineRender = <TArgs extends Record<string, unknown>, TResult>(
+export const useInlineRender = <TArgs extends ReadonlyJSONObject, TResult>(
   toolUI: FC<ToolCallContentPartProps<TArgs, TResult>>,
 ): FC<ToolCallContentPartProps<TArgs, TResult>> => {
   const [useToolUI] = useState(() => create(() => toolUI));

package/src/runtimes/edge/EdgeRuntimeRequestOptions.ts

@@ -4,6 +4,7 @@ import {
   LanguageModelV1CallSettingsSchema,
 } from "../../model-context/ModelContextTypes";
 import { z } from "zod";
+import { ReadonlyJSONObject } from "../../utils/json/json-value";
 
 const LanguageModelV1FunctionToolSchema = z.object({
   type: z.literal("function"),
@@ -42,11 +43,12 @@ const CoreToolCallContentPartSchema = z.object({
   type: z.literal("tool-call"),
   toolCallId: z.string(),
   toolName: z.string(),
-  args: z.record(z.unknown()),
+  args: z
+    .record(z.unknown())
+    .refine((c): c is ReadonlyJSONObject => c !== undefined),
   result: z.unknown().optional(),
   isError: z.boolean().optional(),
 });
-// args is required but unknown;
 
 const CoreUserMessageSchema = z.object({
   role: z.literal("user"),

package/src/runtimes/edge/converters/fromLanguageModelMessages.ts

@@ -1,6 +1,7 @@
 import { LanguageModelV1Message } from "@ai-sdk/provider";
 import { CoreMessage, ToolCallContentPart } from "../../../types";
 import { Writable } from "stream";
+import { ReadonlyJSONObject } from "../../../utils/json/json-value";
 
 type fromLanguageModelMessagesOptions = {
   mergeSteps: boolean;
@@ -76,7 +77,7 @@ export const fromLanguageModelMessages = (
               toolCallId: part.toolCallId,
               toolName: part.toolName,
               argsText: JSON.stringify(part.args),
-              args: part.args as Record<string, unknown>,
+              args: part.args as ReadonlyJSONObject,
             } satisfies ToolCallContentPart;
           }
           return part;

package/src/runtimes/edge/createEdgeRuntimeAPI.ts

@@ -26,7 +26,7 @@ import { streamPartEncoderStream } from "./streams/utils/streamPartEncoderStream
 import { z } from "zod";
 
 type FinishResult = {
-  messages: CoreMessage[];
+  messages: readonly CoreMessage[];
   metadata: {
     steps: readonly ThreadStep[];
   };
@@ -111,7 +111,7 @@ export const getEdgeRuntimeStream = async ({
     abortSignal,
 
     ...(!!system ? { system } : undefined),
-    messages: [...messages],
+    messages,
     tools: lmServerTools.concat(clientTools as LanguageModelV1FunctionTool[]),
     ...(toolChoice ? { toolChoice } : undefined),
   });
@@ -201,7 +201,7 @@ export const createEdgeRuntimeAPI = (options: CreateEdgeRuntimeAPIOptions) => ({
 type StreamMessageOptions = LanguageModelV1CallSettings & {
   model: LanguageModelV1;
   system?: string;
-  messages: CoreMessage[];
+  messages: readonly CoreMessage[];
   tools?: LanguageModelV1FunctionTool[];
   toolChoice?: LanguageModelV1ToolChoice;
   abortSignal: AbortSignal;
@@ -229,7 +229,7 @@ async function streamMessage({
 
 export function convertToLanguageModelPrompt(
   system: string | undefined,
-  messages: CoreMessage[],
+  messages: readonly CoreMessage[],
 ): LanguageModelV1Prompt {
   const languageModelMessages: LanguageModelV1Prompt = [];
 

package/src/runtimes/edge/streams/AssistantStreamChunkType.ts

@@ -1,4 +1,5 @@
-import { JSONValue, LanguageModelV1StreamPart } from "@ai-sdk/provider";
+import { LanguageModelV1StreamPart } from "@ai-sdk/provider";
+import { ReadonlyJSONValue } from "../../../utils/json/json-value";
 
 export enum AssistantStreamChunkType {
   TextDelta = "0",
@@ -17,8 +18,8 @@ export enum AssistantStreamChunkType {
 
 export type AssistantStreamChunk = {
   [AssistantStreamChunkType.TextDelta]: string;
-  [AssistantStreamChunkType.Data]: JSONValue[];
-  [AssistantStreamChunkType.Annotation]: JSONValue[];
+  [AssistantStreamChunkType.Data]: ReadonlyJSONValue[];
+  [AssistantStreamChunkType.Annotation]: ReadonlyJSONValue[];
   [AssistantStreamChunkType.ToolCall]: {
     toolCallId: string;
     toolName: string;

package/src/runtimes/edge/streams/runResultStream.ts

@@ -1,5 +1,5 @@
 import { CoreChatModelRunResult } from "../../local/ChatModelAdapter";
-import { parsePartialJson } from "../partial-json/parse-partial-json";
+import { parsePartialJson } from "../../../utils/json/parse-partial-json";
 import { LanguageModelV1StreamPart } from "@ai-sdk/provider";
 import { ToolResultStreamPart } from "./toolResultStream";
 import { MessageStatus, ToolCallContentPart } from "../../../types";

package/src/runtimes/edge/streams/toolResultStream.ts

@@ -1,17 +1,18 @@
 import { Tool } from "../../../model-context/ModelContextTypes";
-import { JSONValue, LanguageModelV1StreamPart } from "@ai-sdk/provider";
+import { LanguageModelV1StreamPart } from "@ai-sdk/provider";
 import { z } from "zod";
 import sjson from "secure-json-parse";
+import { ReadonlyJSONValue } from "../../../utils/json/json-value";
 
 export type ToolResultStreamPart =
   | LanguageModelV1StreamPart
   | {
       type: "annotations";
-      annotations: JSONValue[];
+      annotations: ReadonlyJSONValue[];
     }
   | {
       type: "data";
-      data: JSONValue[];
+      data: ReadonlyJSONValue[];
     }
   | {
       type: "tool-result";

package/src/runtimes/external-store/ThreadMessageLike.tsx

@@ -18,6 +18,8 @@ import {
   CoreToolCallContentPart,
   ThreadStep,
 } from "../../types/AssistantTypes";
+import { ReadonlyJSONValue } from "../../utils/json/json-value";
+import { parsePartialJson } from "../../utils/json/parse-partial-json";
 
 export type ThreadMessageLike = {
   readonly role: "assistant" | "user" | "system";
@@ -30,6 +32,14 @@ export type ThreadMessageLike = {
         | Unstable_AudioContentPart
         | ToolCallContentPart<any, any>
         | CoreToolCallContentPart<any, any>
+        | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            argsText: string;
+            result?: unknown | undefined;
+            isError?: boolean | undefined;
+          }
         | UIContentPart
       )[];
   readonly id?: string | undefined;
@@ -38,8 +48,10 @@ export type ThreadMessageLike = {
   readonly attachments?: readonly CompleteAttachment[] | undefined;
   readonly metadata?:
     | {
-        readonly unstable_annotations?: readonly unknown[] | undefined;
-        readonly unstable_data?: readonly unknown[] | undefined;
+        readonly unstable_annotations?:
+          | readonly ReadonlyJSONValue[]
+          | undefined;
+        readonly unstable_data?: readonly ReadonlyJSONValue[] | undefined;
         readonly steps?: readonly ThreadStep[] | undefined;
         readonly custom?: Record<string, unknown> | undefined;
       }
@@ -88,7 +100,16 @@ export const fromThreadMessageLike = (
                 return part;
 
               case "tool-call": {
-                if ("argsText" in part) return part;
+                if ("argsText" in part) {
+                  if ("args" in part) {
+                    return part;
+                  }
+
+                  return {
+                    ...part,
+                    args: parsePartialJson(part.argsText),
+                  };
+                }
                 return {
                   ...part,
                   argsText: JSON.stringify(part.args),

package/src/runtimes/local/ChatModelAdapter.tsx

@@ -8,6 +8,7 @@ import type {
   ToolCallContentPart,
 } from "../../types/AssistantTypes";
 import type { ModelContext } from "../../model-context/ModelContextTypes";
+import { ReadonlyJSONValue } from "../../utils/json/json-value";
 
 export type ChatModelRunUpdate = {
   readonly content: readonly ThreadAssistantContentPart[];
@@ -18,8 +19,8 @@ export type ChatModelRunResult = {
   readonly content?: readonly ThreadAssistantContentPart[] | undefined;
   readonly status?: MessageStatus | undefined;
   readonly metadata?: {
-    readonly unstable_annotations?: readonly unknown[] | undefined;
-    readonly unstable_data?: readonly unknown[] | undefined;
+    readonly unstable_annotations?: readonly ReadonlyJSONValue[] | undefined;
+    readonly unstable_data?: readonly ReadonlyJSONValue[] | undefined;
     readonly steps?: readonly ThreadStep[] | undefined;
     readonly custom?: Record<string, unknown> | undefined;
   };

package/src/runtimes/local/LocalThreadRuntimeCore.tsx

@@ -82,6 +82,21 @@ export class LocalThreadRuntimeCore
     if (hasUpdates) this._notifySubscribers();
   }
 
+  private _loadPromise: Promise<void> | undefined;
+  public __internal_load() {
+    if (this._loadPromise) return this._loadPromise;
+
+    const promise = this.adapters.history?.load() ?? Promise.resolve(null);
+
+    this._loadPromise = promise.then((repo) => {
+      if (!repo) return;
+      this.repository.import(repo);
+      this._notifySubscribers();
+    });
+
+    return this._loadPromise;
+  }
+
   public async append(message: AppendMessage): Promise<void> {
     this.ensureInitialized();
 
@@ -89,6 +104,10 @@ export class LocalThreadRuntimeCore
       attachments: message.attachments,
     });
     this.repository.addOrUpdateMessage(message.parentId, newMessage);
+    this._options.adapters.history?.append({
+      parentId: message.parentId,
+      message: newMessage,
+    });
 
     const startRun = message.startRun ?? message.role === "user";
     if (startRun) {
@@ -258,11 +277,28 @@ export class LocalThreadRuntimeCore
         });
       } else {
         updateMessage({
-          status: { type: "incomplete", reason: "error", error: e },
+          status: {
+            type: "incomplete",
+            reason: "error",
+            error:
+              e instanceof Error
+                ? e.message
+                : `[${typeof e}] ${new String(e).toString()}`,
+          },
         });
 
         throw e;
       }
+    } finally {
+      if (
+        message.status.type === "complete" ||
+        message.status.type === "incomplete"
+      ) {
+        await this._options.adapters.history?.append({
+          parentId,
+          message: message,
+        });
+      }
     }
     return message;
   }

package/src/runtimes/local/useLocalRuntime.tsx

@@ -9,6 +9,7 @@ import {
   AssistantRuntimeImpl,
 } from "../../api/AssistantRuntime";
 import { ThreadRuntimeImpl } from "../../internal";
+import { useRuntimeAdapters } from "../adapters/RuntimeAdapterProvider";
 
 export type LocalRuntime = AssistantRuntime & {
   reset: (options?: Parameters<LocalRuntimeCore["reset"]>[0]) => void;
@@ -37,18 +38,24 @@ export const useLocalRuntime = (
   adapter: ChatModelAdapter,
   { initialMessages, ...options }: LocalRuntimeOptions = {},
 ) => {
-  const opt = {
-    ...options,
-    adapters: {
-      ...options.adapters,
-      chatModel: adapter,
-    },
-  };
+  const threadListAdapters = useRuntimeAdapters();
+  const opt = useMemo(
+    () => ({
+      ...options,
+      adapters: {
+        ...threadListAdapters,
+        ...options.adapters,
+        chatModel: adapter,
+      },
+    }),
+    [adapter, options, threadListAdapters],
+  );
 
   const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
 
   useEffect(() => {
     runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
+    runtime.threads.getMainThreadRuntimeCore().__internal_load();
   }, [runtime, opt]);
 
   return useMemo(() => LocalRuntimeImpl.create(runtime), [runtime]);

package/src/runtimes/remote-thread-list/RemoteThreadListThreadListRuntimeCore.tsx

@@ -465,12 +465,7 @@ export class RemoteThreadListThreadListRuntimeCore
   private async _ensureThreadIsNotMain(threadId: string) {
     // if thread is main thread, switch to another thread
     if (threadId === this._mainThreadId) {
-      const lastThreadId = this._state.value.threadIds[0];
-      if (lastThreadId) {
-        await this.switchToThread(lastThreadId);
-      } else {
-        await this.switchToNewThread();
-      }
+      await this.switchToNewThread();
     }
   }
 

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

@@ -3,4 +3,3 @@ export type {
   RemoteThreadListAdapter as unstable_RemoteThreadListAdapter,
   RemoteThreadListSubscriber as unstable_RemoteThreadListSubscriber,
 } from "./types";
-export * from "./cloud";

package/src/types/AssistantTypes.ts

@@ -1,5 +1,9 @@
 import type { ReactNode } from "react";
 import { CompleteAttachment } from "./AttachmentTypes";
+import {
+  ReadonlyJSONObject,
+  ReadonlyJSONValue,
+} from "../utils/json/json-value";
 
 export type MessageRole = "user" | "assistant" | "system";
 
@@ -70,7 +74,7 @@ export type UIContentPart = {
 };
 
 export type CoreToolCallContentPart<
-  TArgs extends Record<string, unknown> = Record<string | number, unknown>,
+  TArgs extends ReadonlyJSONObject = ReadonlyJSONObject,
   TResult = unknown,
 > = {
   readonly type: "tool-call";
@@ -82,7 +86,7 @@ export type CoreToolCallContentPart<
 };
 
 export type ToolCallContentPart<
-  TArgs extends Record<string, unknown> = Record<string | number, unknown>,
+  TArgs extends ReadonlyJSONObject = ReadonlyJSONObject,
   TResult = unknown,
 > = CoreToolCallContentPart<TArgs, TResult> & {
   readonly argsText: string;
@@ -160,7 +164,7 @@ export type MessageStatus =
         | "content-filter"
         | "other"
         | "error";
-      readonly error?: unknown;
+      readonly error?: ReadonlyJSONValue;
     };
 
 export type ThreadSystemMessage = MessageCommonProps & {
@@ -185,8 +189,8 @@ export type ThreadAssistantMessage = MessageCommonProps & {
   readonly content: readonly ThreadAssistantContentPart[];
   readonly status: MessageStatus;
   readonly metadata: {
-    readonly unstable_annotations: readonly unknown[];
-    readonly unstable_data: readonly unknown[];
+    readonly unstable_annotations: readonly ReadonlyJSONValue[];
+    readonly unstable_data: readonly ReadonlyJSONValue[];
     readonly steps: readonly ThreadStep[];
     readonly custom: Record<string, unknown>;
   };
@@ -211,8 +215,8 @@ export type AppendMessage = CoreMessage & {
 type BaseThreadMessage = {
   readonly status?: ThreadAssistantMessage["status"];
   readonly metadata: {
-    readonly unstable_annotations?: readonly unknown[];
-    readonly unstable_data?: readonly unknown[];
+    readonly unstable_annotations?: readonly ReadonlyJSONValue[];
+    readonly unstable_data?: readonly ReadonlyJSONValue[];
     readonly steps?: readonly ThreadStep[];
     readonly custom: Record<string, unknown>;
   };