ai 7.0.79 → 7.0.83

package/src/prompt/normalize-stream-provider-error.ts

@@ -0,0 +1,131 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { isProviderStreamError } from '@ai-sdk/provider-utils';
+import { StreamProviderError } from '../error/stream-provider-error';
+
+/**
+ * Normalizes well-formed provider error payloads without changing existing
+ * Error instances or malformed/unknown values.
+ */
+export function normalizeStreamProviderError(error: unknown): unknown {
+  if (
+    isError(error) ||
+    AISDKError.isInstance(error) ||
+    StreamProviderError.isInstance(error)
+  ) {
+    return error;
+  }
+
+  const outer = asRecord(error);
+  if (outer == null) {
+    return error;
+  }
+
+  const providerStreamError = isProviderStreamError(error);
+  const details = providerStreamError
+    ? outer
+    : (asRecord(asRecord(outer.response)?.error) ??
+      asRecord(outer.error) ??
+      outer);
+
+  if (typeof details.message !== 'string') {
+    return error;
+  }
+
+  const type = getString(details.type) ?? getString(outer.type);
+  const code = getStringOrNumber(details.code) ?? getStringOrNumber(outer.code);
+  const explicitStatusCode =
+    getHttpStatusCode(details.statusCode) ??
+    getHttpStatusCode(outer.statusCode) ??
+    getHttpStatusCode(details.status_code) ??
+    getHttpStatusCode(outer.status_code) ??
+    getHttpStatusCode(details.status) ??
+    getHttpStatusCode(outer.status) ??
+    getHttpStatusCode(details.code) ??
+    getHttpStatusCode(outer.code);
+  const messageMetadata = inferExactMessageMetadata(details.message);
+  const statusCode = explicitStatusCode ?? messageMetadata?.statusCode;
+  const explicitRetryability =
+    getBoolean(details.isRetryable) ??
+    getBoolean(outer.isRetryable) ??
+    getBoolean(details.is_retryable) ??
+    getBoolean(outer.is_retryable);
+
+  return new StreamProviderError({
+    message: details.message,
+    type,
+    code,
+    statusCode,
+    isRetryable:
+      explicitRetryability ??
+      messageMetadata?.isRetryable ??
+      isRetryableStatusCode(statusCode),
+    data: providerStreamError ? error.data : error,
+  });
+}
+
+function inferExactMessageMetadata(
+  message: string,
+): { statusCode: number; isRetryable: true } | undefined {
+  switch (message.trim().toLowerCase()) {
+    case 'overloaded':
+    case 'overloaded error':
+    case 'model overloaded':
+      return { statusCode: 503, isRetryable: true };
+    case 'internal server error':
+      return { statusCode: 500, isRetryable: true };
+    case 'service unavailable':
+      return { statusCode: 503, isRetryable: true };
+    default:
+      return undefined;
+  }
+}
+
+function isRetryableStatusCode(statusCode: number | undefined): boolean {
+  return (
+    statusCode != null &&
+    (statusCode === 408 ||
+      statusCode === 409 ||
+      statusCode === 429 ||
+      statusCode >= 500)
+  );
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value != null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+// `instanceof` misses Error instances created in another JavaScript realm.
+function isError(value: unknown): value is Error {
+  return (
+    value instanceof Error ||
+    Object.prototype.toString.call(value) === '[object Error]'
+  );
+}
+
+function getString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function getStringOrNumber(value: unknown): string | number | undefined {
+  return typeof value === 'string' || typeof value === 'number'
+    ? value
+    : undefined;
+}
+
+function getBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function getHttpStatusCode(value: unknown): number | undefined {
+  const statusCode =
+    typeof value === 'string' && /^\d{3}$/.test(value) ? Number(value) : value;
+
+  return typeof statusCode === 'number' &&
+    Number.isInteger(statusCode) &&
+    statusCode >= 400 &&
+    statusCode <= 599
+    ? statusCode
+    : undefined;
+}

package/src/test/mock-embedding-model-v4.ts

@@ -1,4 +1,5 @@
 import type { EmbeddingModelV4 } from '@ai-sdk/provider';
+import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL } from '@ai-sdk/provider-utils';
 import { notImplemented } from './not-implemented';
 
 export class MockEmbeddingModelV4 implements EmbeddingModelV4 {
@@ -7,6 +8,10 @@ export class MockEmbeddingModelV4 implements EmbeddingModelV4 {
   readonly provider: EmbeddingModelV4['provider'];
   readonly modelId: EmbeddingModelV4['modelId'];
   readonly maxEmbeddingsPerCall: EmbeddingModelV4['maxEmbeddingsPerCall'];
+  readonly [EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL]:
+    | PromiseLike<number | undefined>
+    | number
+    | undefined;
   readonly supportsParallelCalls: EmbeddingModelV4['supportsParallelCalls'];
 
   doEmbed: EmbeddingModelV4['doEmbed'];
@@ -17,12 +22,14 @@ export class MockEmbeddingModelV4 implements EmbeddingModelV4 {
     provider = 'mock-provider',
     modelId = 'mock-model-id',
     maxEmbeddingsPerCall = 1,
+    maxInputBytesPerCall,
     supportsParallelCalls = false,
     doEmbed = notImplemented,
   }: {
     provider?: EmbeddingModelV4['provider'];
     modelId?: EmbeddingModelV4['modelId'];
     maxEmbeddingsPerCall?: EmbeddingModelV4['maxEmbeddingsPerCall'] | null;
+    maxInputBytesPerCall?: PromiseLike<number | undefined> | number | undefined;
     supportsParallelCalls?: EmbeddingModelV4['supportsParallelCalls'];
     doEmbed?:
       | EmbeddingModelV4['doEmbed']
@@ -32,6 +39,8 @@ export class MockEmbeddingModelV4 implements EmbeddingModelV4 {
     this.provider = provider;
     this.modelId = modelId;
     this.maxEmbeddingsPerCall = maxEmbeddingsPerCall ?? undefined;
+    this[EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL] =
+      maxInputBytesPerCall;
     this.supportsParallelCalls = supportsParallelCalls;
     this.doEmbed = async options => {
       this.doEmbedCalls.push(options);

package/src/ui/convert-to-model-messages.ts

@@ -233,6 +233,9 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                       approvalId: part.approval.id,
                       toolCallId: part.toolCallId,
                       isAutomatic: part.approval.isAutomatic,
+                      ...(part.approval.requestReason != null
+                        ? { reason: part.approval.requestReason }
+                        : {}),
                       ...(part.approval.signature != null
                         ? { signature: part.approval.signature }
                         : {}),

package/src/ui/direct-chat-transport.ts

@@ -11,7 +11,7 @@ import type {
   InferUITools,
   UIMessage,
 } from './ui-messages';
-import { validateUIMessages } from './validate-ui-messages';
+import { validateUIMessagesForAgent } from './validate-ui-messages';
 
 /**
  * Options for the `DirectChatTransport` class.
@@ -93,7 +93,7 @@ export class DirectChatTransport<
     ReadableStream<UIMessageChunk>
   > {
     // Validate the incoming UI messages
-    const validatedMessages = await validateUIMessages<UI_MESSAGE>({
+    const validatedMessages = await validateUIMessagesForAgent<UI_MESSAGE>({
       messages,
       // tools are compatible; the casting is required because the context param is
       // not available in ui messages

package/src/ui/last-assistant-message-is-complete-with-approval-responses.ts

@@ -36,6 +36,7 @@ export function lastAssistantMessageIsCompleteWithApprovalResponses({
       part =>
         part.state === 'output-available' ||
         part.state === 'output-error' ||
+        part.state === 'output-denied' ||
         part.state === 'approval-responded',
     )
   );

package/src/ui/process-ui-message-stream.ts

@@ -748,6 +748,9 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
               toolInvocation.state = 'approval-requested';
               toolInvocation.approval = {
                 id: chunk.approvalId,
+                ...(chunk.reason != null
+                  ? { requestReason: chunk.reason }
+                  : {}),
                 ...(chunk.isAutomatic === true ? { isAutomatic: true } : {}),
                 ...(chunk.signature != null
                   ? { signature: chunk.signature }
@@ -770,6 +773,9 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
               toolInvocation.approval = {
                 id: chunk.approvalId,
                 approved: chunk.approved,
+                ...(approval.requestReason != null
+                  ? { requestReason: approval.requestReason }
+                  : {}),
                 ...(chunk.reason != null ? { reason: chunk.reason } : {}),
                 ...(approval.isAutomatic === true ? { isAutomatic: true } : {}),
                 ...(approval.signature != null

package/src/ui/ui-messages.ts

@@ -319,6 +319,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
       approval: {
         id: string;
         approved?: never;
+        requestReason?: string;
         reason?: never;
         isAutomatic?: boolean;
         signature?: string;
@@ -333,6 +334,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
       approval: {
         id: string;
         approved: boolean;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -349,6 +351,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
       approval?: {
         id: string;
         approved: true;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -365,6 +368,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
       approval?: {
         id: string;
         approved: true;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -379,6 +383,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
       approval: {
         id: string;
         approved: false;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -437,6 +442,7 @@ export type DynamicToolUIPart = {
       approval: {
         id: string;
         approved?: never;
+        requestReason?: string;
         reason?: never;
         isAutomatic?: boolean;
         signature?: string;
@@ -451,6 +457,7 @@ export type DynamicToolUIPart = {
       approval: {
         id: string;
         approved: boolean;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -467,6 +474,7 @@ export type DynamicToolUIPart = {
       approval?: {
         id: string;
         approved: true;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -482,6 +490,7 @@ export type DynamicToolUIPart = {
       approval?: {
         id: string;
         approved: true;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;
@@ -496,6 +505,7 @@ export type DynamicToolUIPart = {
       approval: {
         id: string;
         approved: false;
+        requestReason?: string;
         reason?: string;
         isAutomatic?: boolean;
         signature?: string;

package/src/ui/validate-ui-messages.ts

@@ -1,6 +1,7 @@
 import { TypeValidationError, type JSONObject } from '@ai-sdk/provider';
 import {
   lazySchema,
+  safeValidateTypes,
   validateTypes,
   zodSchema,
   type FlexibleSchema,
@@ -13,6 +14,7 @@ import { providerMetadataSchema } from '../types/provider-metadata';
 import { z, type ZodType } from '../util/zod';
 import type {
   DataUIPart,
+  DynamicToolUIPart,
   InferUIMessageData,
   InferUIMessageTools,
   ToolUIPart,
@@ -26,6 +28,25 @@ const toolMetadataSchema: ZodType<JSONObject> = z.record(
 
 const providerReferenceSchema = z.record(z.string(), z.string());
 
+function isEmptyObject(value: unknown): value is Record<string, never> {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 0
+  );
+}
+
+function asDynamicToolPart(toolPart: ToolUIPart): DynamicToolUIPart {
+  const { type, ...part } = toolPart;
+
+  return {
+    ...part,
+    type: 'dynamic-tool',
+    toolName: type.slice(5),
+  } as DynamicToolUIPart;
+}
+
 const uiMessagesSchema = lazySchema(() =>
   zodSchema(
     z
@@ -132,6 +153,7 @@ const uiMessagesSchema = lazySchema(() =>
                   approval: z.object({
                     id: z.string(),
                     approved: z.never().optional(),
+                    requestReason: z.string().optional(),
                     reason: z.never().optional(),
                     isAutomatic: z.boolean().optional(),
                     signature: z.string().optional(),
@@ -151,6 +173,7 @@ const uiMessagesSchema = lazySchema(() =>
                   approval: z.object({
                     id: z.string(),
                     approved: z.boolean(),
+                    requestReason: z.string().optional(),
                     reason: z.string().optional(),
                     isAutomatic: z.boolean().optional(),
                     signature: z.string().optional(),
@@ -173,6 +196,7 @@ const uiMessagesSchema = lazySchema(() =>
                     .object({
                       id: z.string(),
                       approved: z.literal(true),
+                      requestReason: z.string().optional(),
                       reason: z.string().optional(),
                       isAutomatic: z.boolean().optional(),
                       signature: z.string().optional(),
@@ -196,6 +220,7 @@ const uiMessagesSchema = lazySchema(() =>
                     .object({
                       id: z.string(),
                       approved: z.literal(true),
+                      requestReason: z.string().optional(),
                       reason: z.string().optional(),
                       isAutomatic: z.boolean().optional(),
                       signature: z.string().optional(),
@@ -216,6 +241,7 @@ const uiMessagesSchema = lazySchema(() =>
                   approval: z.object({
                     id: z.string(),
                     approved: z.literal(false),
+                    requestReason: z.string().optional(),
                     reason: z.string().optional(),
                     isAutomatic: z.boolean().optional(),
                     signature: z.string().optional(),
@@ -258,6 +284,7 @@ const uiMessagesSchema = lazySchema(() =>
                   approval: z.object({
                     id: z.string(),
                     approved: z.never().optional(),
+                    requestReason: z.string().optional(),
                     reason: z.never().optional(),
                     isAutomatic: z.boolean().optional(),
                     signature: z.string().optional(),
@@ -276,6 +303,7 @@ const uiMessagesSchema = lazySchema(() =>
                   approval: z.object({
                     id: z.string(),
                     approved: z.boolean(),
+                    requestReason: z.string().optional(),
                     reason: z.string().optional(),
                     isAutomatic: z.boolean().optional(),
                     signature: z.string().optional(),
@@ -297,6 +325,7 @@ const uiMessagesSchema = lazySchema(() =>
                     .object({
                       id: z.string(),
                       approved: z.literal(true),
+                      requestReason: z.string().optional(),
                       reason: z.string().optional(),
                       isAutomatic: z.boolean().optional(),
                       signature: z.string().optional(),
@@ -319,6 +348,7 @@ const uiMessagesSchema = lazySchema(() =>
                     .object({
                       id: z.string(),
                       approved: z.literal(true),
+                      requestReason: z.string().optional(),
                       reason: z.string().optional(),
                       isAutomatic: z.boolean().optional(),
                       signature: z.string().optional(),
@@ -338,6 +368,7 @@ const uiMessagesSchema = lazySchema(() =>
                   approval: z.object({
                     id: z.string(),
                     approved: z.literal(false),
+                    requestReason: z.string().optional(),
                     reason: z.string().optional(),
                     isAutomatic: z.boolean().optional(),
                     signature: z.string().optional(),
@@ -374,17 +405,7 @@ export type SafeValidateUIMessagesResult<UI_MESSAGE extends UIMessage> =
       error: Error;
     };
 
-/**
- * Validates a list of UI messages like `validateUIMessages`,
- * but instead of throwing it returns `{ success: true, data }`
- * or `{ success: false, error }`.
- */
-export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools,
-}: {
+type ValidateUIMessagesOptions<UI_MESSAGE extends UIMessage> = {
   messages: unknown;
   metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
   dataSchemas?: {
@@ -398,7 +419,21 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
       InferUIMessageTools<UI_MESSAGE>[NAME]['output']
     >;
   };
-}): Promise<SafeValidateUIMessagesResult<UI_MESSAGE>> {
+};
+
+async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
+  {
+    messages,
+    metadataSchema,
+    dataSchemas,
+    tools,
+  }: ValidateUIMessagesOptions<UI_MESSAGE>,
+  {
+    convertMissingTerminalToolsToDynamic,
+  }: {
+    convertMissingTerminalToolsToDynamic: boolean;
+  },
+): Promise<SafeValidateUIMessagesResult<UI_MESSAGE>> {
   try {
     if (messages == null) {
       return {
@@ -429,7 +464,10 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
       }
     }
 
-    if (dataSchemas || tools) {
+    const shouldValidateToolParts =
+      tools != null || convertMissingTerminalToolsToDynamic;
+
+    if (dataSchemas || shouldValidateToolParts) {
       for (const [msgIdx, message] of validatedMessages.entries()) {
         for (const [partIdx, part] of message.parts.entries()) {
           // Data part validation
@@ -465,19 +503,26 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
           }
 
           // Tool part validation
-          if (tools && part.type.startsWith('tool-')) {
+          if (shouldValidateToolParts && part.type.startsWith('tool-')) {
             const toolPart = part as ToolUIPart<
               InferUIMessageTools<UI_MESSAGE>
             >;
             const toolName = toolPart.type.slice(5);
-            const tool = getOwn(tools, toolName);
+            const tool = tools == null ? undefined : getOwn(tools, toolName);
+            const isTerminal =
+              toolPart.state === 'output-available' ||
+              toolPart.state === 'output-error' ||
+              toolPart.state === 'output-denied';
 
-            if (
-              !tool &&
-              (toolPart.state === 'output-available' ||
-                toolPart.state === 'output-error' ||
-                toolPart.state === 'output-denied')
-            ) {
+            if (!tool && isTerminal) {
+              if (tools != null || convertMissingTerminalToolsToDynamic) {
+                // Persisted terminal history can reference tools that are no
+                // longer registered. Normalize those parts so callers do not
+                // receive unvalidated values under current static tool types.
+                message.parts[partIdx] = asDynamicToolPart(
+                  toolPart,
+                ) as (typeof message.parts)[number];
+              }
               continue;
             }
 
@@ -497,19 +542,53 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
               };
             }
 
+            const inputValidationContext = {
+              field: `messages[${msgIdx}].parts[${partIdx}].input`,
+              entityName: toolName,
+              entityId: toolPart.toolCallId,
+            };
+            let convertToDynamic = false;
+
             // Tool input validation
-            // Note: input is intentionally not re-validated for terminal states.
-            // Terminal tool calls can keep invalid or incomplete input, and
-            // re-validating it on replay would crash follow-up messages.
-            if (toolPart.state === 'input-available') {
+            if (toolPart.state === 'output-error') {
+              // Failed calls can retain invalid input. Keep them loadable, but
+              // expose incompatible input as unknown instead of the current
+              // static tool input type.
+              if (toolPart.input !== undefined) {
+                const result = await safeValidateTypes({
+                  value: toolPart.input,
+                  schema: tool.inputSchema,
+                  context: inputValidationContext,
+                });
+                convertToDynamic = !result.success;
+              }
+            } else if (toolPart.state === 'output-available') {
+              const result = await safeValidateTypes({
+                value: toolPart.input,
+                schema: tool.inputSchema,
+                context: inputValidationContext,
+              });
+
+              if (!result.success) {
+                // Empty terminal input can represent aborted or incomplete
+                // history whose input was never streamed. Preserve it without
+                // claiming that it matches the current static input type.
+                if (isEmptyObject(toolPart.input)) {
+                  convertToDynamic = true;
+                } else {
+                  throw result.error;
+                }
+              }
+            } else if (
+              toolPart.state === 'input-available' ||
+              toolPart.state === 'approval-requested' ||
+              toolPart.state === 'approval-responded' ||
+              toolPart.state === 'output-denied'
+            ) {
               await validateTypes({
                 value: toolPart.input,
                 schema: tool.inputSchema,
-                context: {
-                  field: `messages[${msgIdx}].parts[${partIdx}].input`,
-                  entityName: toolName,
-                  entityId: toolPart.toolCallId,
-                },
+                context: inputValidationContext,
               });
             }
 
@@ -525,6 +604,12 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
                 },
               });
             }
+
+            if (convertToDynamic) {
+              message.parts[partIdx] = asDynamicToolPart(
+                toolPart,
+              ) as (typeof message.parts)[number];
+            }
           }
         }
       }
@@ -544,6 +629,19 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
   }
 }
 
+/**
+ * Validates a list of UI messages like `validateUIMessages`,
+ * but instead of throwing it returns `{ success: true, data }`
+ * or `{ success: false, error }`.
+ */
+export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>(
+  options: ValidateUIMessagesOptions<UI_MESSAGE>,
+): Promise<SafeValidateUIMessagesResult<UI_MESSAGE>> {
+  return safeValidateUIMessagesInternal(options, {
+    convertMissingTerminalToolsToDynamic: false,
+  });
+}
+
 /**
  * Validates a list of UI messages.
  *
@@ -551,31 +649,24 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
  * the corresponding schemas are provided. Otherwise, they are assumed to be
  * valid.
  */
-export async function validateUIMessages<UI_MESSAGE extends UIMessage>({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools,
-}: {
-  messages: unknown;
-  metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
-  dataSchemas?: {
-    [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<
-      InferUIMessageData<UI_MESSAGE>[NAME]
-    >;
-  };
-  tools?: {
-    [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<
-      InferUIMessageTools<UI_MESSAGE>[NAME]['input'],
-      InferUIMessageTools<UI_MESSAGE>[NAME]['output']
-    >;
-  };
-}): Promise<Array<UI_MESSAGE>> {
-  const response = await safeValidateUIMessages({
-    messages,
-    metadataSchema,
-    dataSchemas,
-    tools,
+export async function validateUIMessages<UI_MESSAGE extends UIMessage>(
+  options: ValidateUIMessagesOptions<UI_MESSAGE>,
+): Promise<Array<UI_MESSAGE>> {
+  const response = await safeValidateUIMessages(options);
+
+  if (!response.success) throw response.error;
+
+  return response.data;
+}
+
+export async function validateUIMessagesForAgent<UI_MESSAGE extends UIMessage>(
+  options: ValidateUIMessagesOptions<UI_MESSAGE>,
+): Promise<Array<UI_MESSAGE>> {
+  const response = await safeValidateUIMessagesInternal(options, {
+    // Agent tool sets can include ephemeral tools (for example, tools from a
+    // disconnected MCP server), so terminal history is converted to dynamic
+    // tool parts when those tools are no longer registered.
+    convertMissingTerminalToolsToDynamic: true,
   });
 
   if (!response.success) throw response.error;