@directus/api 33.3.1 → 34.0.1

package/dist/ai/chat/lib/create-ui-stream.js

@@ -3,6 +3,7 @@ import { convertToModelMessages, stepCountIs, streamText, } from 'ai';
 import { buildProviderConfigs, createAIProviderRegistry, getProviderOptions, } from '../../providers/index.js';
 import { SYSTEM_PROMPT } from '../constants/system-prompt.js';
 import { formatContextForSystemPrompt } from '../utils/format-context.js';
+import { transformFilePartsForProvider } from './transform-file-parts.js';
 export const createUiStream = async (messages, { provider, model, tools, aiSettings, systemPrompt, context, onUsage }) => {
     const configs = buildProviderConfigs(aiSettings);
     const providerConfig = configs.find((c) => c.type === provider);
@@ -18,7 +19,7 @@ export const createUiStream = async (messages, { provider, model, tools, aiSetti
     const stream = streamText({
         system: baseSystemPrompt,
         model: registry.languageModel(`${provider}:${model}`),
-        messages: await convertToModelMessages(messages),
+        messages: await convertToModelMessages(transformFilePartsForProvider(messages)),
         stopWhen: [stepCountIs(10)],
         providerOptions,
         tools,

package/dist/ai/chat/lib/transform-file-parts.d.ts

@@ -0,0 +1,12 @@
+import type { UIMessage } from 'ai';
+/**
+ * Transforms UIMessage file parts to use provider file_id instead of display URL.
+ *
+ * The frontend sends files with:
+ * - url: display URL for UI rendering (blob: or /assets/ URL)
+ * - providerMetadata.directus.fileId: the actual provider file ID
+ *
+ * This function replaces the url with the fileId so the AI SDK can use it
+ * with the provider's native file handling.
+ */
+export declare function transformFilePartsForProvider(messages: UIMessage[]): UIMessage[];

package/dist/ai/chat/lib/transform-file-parts.js

@@ -0,0 +1,36 @@
+import { useLogger } from '../../../logger/index.js';
+function isFileUIPart(part) {
+    return typeof part === 'object' && part !== null && part.type === 'file';
+}
+/**
+ * Transforms UIMessage file parts to use provider file_id instead of display URL.
+ *
+ * The frontend sends files with:
+ * - url: display URL for UI rendering (blob: or /assets/ URL)
+ * - providerMetadata.directus.fileId: the actual provider file ID
+ *
+ * This function replaces the url with the fileId so the AI SDK can use it
+ * with the provider's native file handling.
+ */
+export function transformFilePartsForProvider(messages) {
+    const logger = useLogger();
+    return messages.map((msg) => {
+        if (!Array.isArray(msg.parts)) {
+            return msg;
+        }
+        const parts = [];
+        for (const part of msg.parts) {
+            if (!isFileUIPart(part)) {
+                parts.push(part);
+                continue;
+            }
+            const fileId = part.providerMetadata?.directus?.fileId;
+            if (!fileId) {
+                logger.warn('File part missing providerMetadata.directus.fileId, filtering out');
+                continue;
+            }
+            parts.push({ ...part, url: fileId });
+        }
+        return { ...msg, parts };
+    });
+}

package/dist/ai/files/adapters/anthropic.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderFileRef } from '@directus/ai';
+import type { UploadedFile } from '../types.js';
+export declare function uploadToAnthropic(file: UploadedFile, apiKey: string): Promise<ProviderFileRef>;

package/dist/ai/files/adapters/anthropic.js

@@ -0,0 +1,25 @@
+import { fetchProvider } from '../lib/fetch-provider.js';
+export async function uploadToAnthropic(file, apiKey) {
+    const formData = new FormData();
+    formData.append('file', new Blob([new Uint8Array(file.data)], { type: file.mimeType }), file.filename);
+    const result = (await fetchProvider('https://api.anthropic.com/v1/files', {
+        method: 'POST',
+        headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'anthropic-beta': 'files-api-2025-04-14',
+        },
+        body: formData,
+    }, 'Anthropic'));
+    if (!result.id) {
+        throw new Error('Anthropic upload returned unexpected response');
+    }
+    return {
+        provider: 'anthropic',
+        fileId: result.id,
+        filename: result.filename ?? file.filename,
+        mimeType: result.mime_type ?? file.mimeType,
+        sizeBytes: result.size_bytes ?? file.data.length,
+        expiresAt: null,
+    };
+}

package/dist/ai/files/adapters/google.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderFileRef } from '@directus/ai';
+import type { UploadedFile } from '../types.js';
+export declare function uploadToGoogle(file: UploadedFile, apiKey: string): Promise<ProviderFileRef>;

package/dist/ai/files/adapters/google.js

@@ -0,0 +1,58 @@
+import { fetchProvider } from '../lib/fetch-provider.js';
+export async function uploadToGoogle(file, apiKey) {
+    const baseUrl = 'https://generativelanguage.googleapis.com/upload/v1beta/files';
+    // Use a manual fetch here since we need the response headers, not JSON
+    const UPLOAD_TIMEOUT = 120_000;
+    let startResponse;
+    try {
+        startResponse = await fetch(baseUrl, {
+            method: 'POST',
+            headers: {
+                'x-goog-api-key': apiKey,
+                'X-Goog-Upload-Protocol': 'resumable',
+                'X-Goog-Upload-Command': 'start',
+                'X-Goog-Upload-Header-Content-Length': String(file.data.length),
+                'X-Goog-Upload-Header-Content-Type': file.mimeType,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ file: { display_name: file.filename } }),
+            signal: AbortSignal.timeout(UPLOAD_TIMEOUT),
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && (error.name === 'AbortError' || error.name === 'TimeoutError')) {
+            throw new Error(`Google upload timed out after ${UPLOAD_TIMEOUT / 1000}s`);
+        }
+        throw error;
+    }
+    if (!startResponse.ok) {
+        const text = await startResponse.text().catch(() => `HTTP ${startResponse.status}`);
+        throw new Error(`Google upload init failed: ${text}`);
+    }
+    const uploadUrl = startResponse.headers.get('X-Goog-Upload-URL');
+    if (!uploadUrl) {
+        throw new Error('Google upload init did not return upload URL');
+    }
+    const result = (await fetchProvider(uploadUrl, {
+        method: 'POST',
+        headers: {
+            'X-Goog-Upload-Command': 'upload, finalize',
+            'X-Goog-Upload-Offset': '0',
+            'Content-Type': file.mimeType,
+        },
+        body: new Uint8Array(file.data),
+    }, 'Google'));
+    const fileData = result.file;
+    if (!fileData?.uri) {
+        throw new Error('Google upload returned unexpected response');
+    }
+    const parsedSize = parseInt(fileData.sizeBytes ?? '', 10);
+    return {
+        provider: 'google',
+        fileId: fileData.uri,
+        filename: fileData.displayName ?? file.filename,
+        mimeType: fileData.mimeType ?? file.mimeType,
+        sizeBytes: Number.isNaN(parsedSize) ? file.data.length : parsedSize,
+        expiresAt: fileData.expirationTime ?? null,
+    };
+}

package/dist/ai/files/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export { uploadToOpenAI } from './openai.js';
+export { uploadToAnthropic } from './anthropic.js';
+export { uploadToGoogle } from './google.js';

package/dist/ai/files/adapters/index.js

@@ -0,0 +1,3 @@
+export { uploadToOpenAI } from './openai.js';
+export { uploadToAnthropic } from './anthropic.js';
+export { uploadToGoogle } from './google.js';

package/dist/ai/files/adapters/openai.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderFileRef } from '@directus/ai';
+import type { UploadedFile } from '../types.js';
+export declare function uploadToOpenAI(file: UploadedFile, apiKey: string): Promise<ProviderFileRef>;

package/dist/ai/files/adapters/openai.js

@@ -0,0 +1,22 @@
+import { fetchProvider } from '../lib/fetch-provider.js';
+export async function uploadToOpenAI(file, apiKey) {
+    const formData = new FormData();
+    formData.append('file', new Blob([new Uint8Array(file.data)], { type: file.mimeType }), file.filename);
+    formData.append('purpose', 'user_data');
+    const result = (await fetchProvider('https://api.openai.com/v1/files', {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: formData,
+    }, 'OpenAI'));
+    if (!result.id) {
+        throw new Error('OpenAI upload returned unexpected response');
+    }
+    return {
+        provider: 'openai',
+        fileId: result.id,
+        filename: file.filename,
+        mimeType: file.mimeType,
+        sizeBytes: result.bytes ?? file.data.length,
+        expiresAt: null,
+    };
+}

package/dist/ai/files/controllers/upload.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'express';
+export declare const aiFileUploadHandler: RequestHandler;

package/dist/ai/files/controllers/upload.js

@@ -0,0 +1,101 @@
+import { AI_ALLOWED_MIME_TYPES } from '@directus/ai';
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
+import Busboy from 'busboy';
+import { useLogger } from '../../../logger/index.js';
+import { uploadToProvider } from '../lib/upload-to-provider.js';
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+const ALLOWED_MIME_TYPES = new Set(AI_ALLOWED_MIME_TYPES);
+const SUPPORTED_PROVIDERS = new Set(['openai', 'anthropic', 'google']);
+function isSupportedProvider(provider) {
+    return SUPPORTED_PROVIDERS.has(provider);
+}
+async function parseMultipart(headers, stream) {
+    const contentType = headers['content-type'];
+    if (!contentType || !contentType.toLowerCase().startsWith('multipart/')) {
+        throw new InvalidPayloadError({ reason: 'Expected multipart/form-data content type' });
+    }
+    return new Promise((resolve, reject) => {
+        let file;
+        let provider;
+        let settled = false;
+        const safeReject = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        };
+        const bb = Busboy({
+            headers: headers,
+            limits: { fileSize: MAX_FILE_SIZE, files: 1 },
+        });
+        bb.on('file', (_name, fileStream, info) => {
+            const chunks = [];
+            let exceeded = false;
+            fileStream.on('data', (chunk) => chunks.push(chunk));
+            fileStream.on('limit', () => {
+                exceeded = true;
+                fileStream.destroy();
+                safeReject(new InvalidPayloadError({ reason: `File exceeds maximum size of ${MAX_FILE_SIZE / (1024 * 1024)}MB` }));
+            });
+            fileStream.on('close', () => {
+                if (exceeded)
+                    return;
+                file = {
+                    filename: info.filename || 'file',
+                    mimeType: info.mimeType,
+                    data: Buffer.concat(chunks),
+                };
+            });
+            fileStream.on('error', safeReject);
+        });
+        bb.on('field', (name, value) => {
+            if (name === 'provider')
+                provider = value;
+        });
+        bb.on('close', () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ file, provider });
+        });
+        bb.on('error', safeReject);
+        stream.pipe(bb);
+    });
+}
+export const aiFileUploadHandler = async (req, res, next) => {
+    const logger = useLogger();
+    try {
+        if (!req.accountability?.app) {
+            throw new ForbiddenError();
+        }
+        const aiSettings = res.locals['ai']?.settings;
+        if (!aiSettings) {
+            throw new InvalidPayloadError({ reason: 'AI settings not loaded' });
+        }
+        const { file, provider } = await parseMultipart(req.headers, req);
+        if (!file) {
+            throw new InvalidPayloadError({ reason: 'No file provided' });
+        }
+        if (!provider) {
+            throw new InvalidPayloadError({ reason: 'No provider specified' });
+        }
+        if (!isSupportedProvider(provider)) {
+            throw new InvalidPayloadError({
+                reason: provider === 'openai-compatible'
+                    ? 'File uploads not supported for openai-compatible provider'
+                    : `Unsupported provider: ${provider}`,
+            });
+        }
+        if (!ALLOWED_MIME_TYPES.has(file.mimeType)) {
+            throw new InvalidPayloadError({ reason: `Unsupported file type: ${file.mimeType}` });
+        }
+        const result = await uploadToProvider(file, provider, aiSettings);
+        res.json(result);
+    }
+    catch (error) {
+        if (error instanceof Error && !(error instanceof ForbiddenError) && !(error instanceof InvalidPayloadError)) {
+            logger.error(error, 'AI file upload failed');
+        }
+        next(error);
+    }
+};

package/dist/ai/files/lib/fetch-provider.d.ts

@@ -0,0 +1 @@
+export declare function fetchProvider(url: string, options: RequestInit, providerName: string): Promise<unknown>;

package/dist/ai/files/lib/fetch-provider.js

@@ -0,0 +1,23 @@
+const UPLOAD_TIMEOUT = 120_000;
+export async function fetchProvider(url, options, providerName) {
+    let response;
+    try {
+        response = await fetch(url, { ...options, signal: AbortSignal.timeout(UPLOAD_TIMEOUT) });
+    }
+    catch (error) {
+        if (error instanceof Error && (error.name === 'AbortError' || error.name === 'TimeoutError')) {
+            throw new Error(`${providerName} upload timed out after ${UPLOAD_TIMEOUT / 1000}s`);
+        }
+        throw error;
+    }
+    if (!response.ok) {
+        const text = await response.text().catch(() => `HTTP ${response.status}`);
+        throw new Error(`${providerName} upload failed: ${text}`);
+    }
+    try {
+        return await response.json();
+    }
+    catch (cause) {
+        throw new Error(`${providerName} upload succeeded but returned invalid response`, { cause });
+    }
+}

package/dist/ai/files/lib/upload-to-provider.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderFileRef, StandardProviderType } from '@directus/ai';
+import type { AISettings } from '../../providers/types.js';
+import type { UploadedFile } from '../types.js';
+export declare function uploadToProvider(file: UploadedFile, provider: StandardProviderType, settings: AISettings): Promise<ProviderFileRef>;

package/dist/ai/files/lib/upload-to-provider.js

@@ -0,0 +1,26 @@
+import { InvalidPayloadError } from '@directus/errors';
+import { uploadToAnthropic, uploadToGoogle, uploadToOpenAI } from '../adapters/index.js';
+export async function uploadToProvider(file, provider, settings) {
+    switch (provider) {
+        case 'openai': {
+            if (!settings.openaiApiKey) {
+                throw new InvalidPayloadError({ reason: 'OpenAI API key not configured' });
+            }
+            return uploadToOpenAI(file, settings.openaiApiKey);
+        }
+        case 'anthropic': {
+            if (!settings.anthropicApiKey) {
+                throw new InvalidPayloadError({ reason: 'Anthropic API key not configured' });
+            }
+            return uploadToAnthropic(file, settings.anthropicApiKey);
+        }
+        case 'google': {
+            if (!settings.googleApiKey) {
+                throw new InvalidPayloadError({ reason: 'Google API key not configured' });
+            }
+            return uploadToGoogle(file, settings.googleApiKey);
+        }
+        default:
+            throw new InvalidPayloadError({ reason: `Provider ${provider} does not support file uploads` });
+    }
+}

package/dist/ai/files/router.d.ts

@@ -0,0 +1 @@
+export declare const aiFilesRouter: import("express-serve-static-core").Router;

package/dist/ai/files/router.js

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+import asyncHandler from '../../utils/async-handler.js';
+import { loadSettings } from '../chat/middleware/load-settings.js';
+import { aiFileUploadHandler } from './controllers/upload.js';
+export const aiFilesRouter = Router().post('/', asyncHandler(loadSettings), asyncHandler(aiFileUploadHandler));

package/dist/ai/files/types.d.ts

@@ -0,0 +1,5 @@
+export interface UploadedFile {
+    filename: string;
+    mimeType: string;
+    data: Buffer;
+}

package/dist/ai/files/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ai/providers/anthropic-file-support.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates an Anthropic provider with file_id support.
+ *
+ * The AI SDK's @ai-sdk/anthropic provider doesn't support Anthropic's Files API file_id.
+ * This wrapper intercepts the HTTP request and transforms base64 sources that contain
+ * a file_id marker into the native Anthropic file source format.
+ *
+ * When the AI SDK converts a FileUIPart with url=file_id, it creates a base64 source
+ * with the file_id as the data (since it's not a valid URL or base64). We detect this
+ * pattern and transform it to use the native file source type.
+ */
+export declare function createAnthropicWithFileSupport(apiKey: string): import("@ai-sdk/anthropic").AnthropicProvider;

package/dist/ai/providers/anthropic-file-support.js

@@ -0,0 +1,94 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { useLogger } from '../../logger/index.js';
+/**
+ * Creates an Anthropic provider with file_id support.
+ *
+ * The AI SDK's @ai-sdk/anthropic provider doesn't support Anthropic's Files API file_id.
+ * This wrapper intercepts the HTTP request and transforms base64 sources that contain
+ * a file_id marker into the native Anthropic file source format.
+ *
+ * When the AI SDK converts a FileUIPart with url=file_id, it creates a base64 source
+ * with the file_id as the data (since it's not a valid URL or base64). We detect this
+ * pattern and transform it to use the native file source type.
+ */
+export function createAnthropicWithFileSupport(apiKey) {
+    return createAnthropic({
+        apiKey,
+        fetch: async (url, options) => {
+            if (!options?.body || typeof options.body !== 'string') {
+                return fetch(url, options);
+            }
+            try {
+                const body = JSON.parse(options.body);
+                if (!body.messages) {
+                    return fetch(url, options);
+                }
+                const { messages, hasFileIds } = transformMessagesForFileId(body.messages);
+                body.messages = messages;
+                const headersObj = {};
+                if (options.headers instanceof Headers) {
+                    options.headers.forEach((value, key) => {
+                        headersObj[key] = value;
+                    });
+                }
+                else {
+                    Object.assign(headersObj, options.headers);
+                }
+                if (hasFileIds) {
+                    const existing = headersObj['anthropic-beta'];
+                    const betaFlag = 'files-api-2025-04-14';
+                    if (!existing?.includes(betaFlag)) {
+                        headersObj['anthropic-beta'] = existing ? `${existing},${betaFlag}` : betaFlag;
+                    }
+                }
+                return fetch(url, {
+                    ...options,
+                    headers: headersObj,
+                    body: JSON.stringify(body),
+                });
+            }
+            catch (error) {
+                const logger = useLogger();
+                logger.error('Anthropic file support: could not parse request body');
+                throw error;
+            }
+        },
+    });
+}
+/**
+ * Transforms messages to use file_id source type where applicable.
+ *
+ * The AI SDK converts FileUIPart.url to base64 source data. When url is a file_id
+ * (starts with "file_"), the data field contains the file_id string.
+ * We detect this and convert to native Anthropic file source format.
+ */
+function transformMessagesForFileId(messages) {
+    let hasFileIds = false;
+    const transformedMessages = messages.map((msg) => {
+        if (!msg.content || !Array.isArray(msg.content)) {
+            return msg;
+        }
+        return {
+            ...msg,
+            content: msg.content.map((block) => {
+                // Check if this is an image or document with base64 source
+                if ((block.type === 'image' || block.type === 'document') &&
+                    block.source?.type === 'base64' &&
+                    typeof block.source.data === 'string' &&
+                    block.source.data.startsWith('file_')) {
+                    const fileId = block.source.data;
+                    hasFileIds = true;
+                    return {
+                        ...block,
+                        source: {
+                            type: 'file',
+                            file_id: fileId,
+                        },
+                    };
+                }
+                return block;
+            }),
+        };
+    });
+    return { messages: transformedMessages, hasFileIds };
+}

package/dist/ai/providers/registry.js

@@ -1,8 +1,8 @@
-import { createAnthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { createProviderRegistry } from 'ai';
+import { createAnthropicWithFileSupport } from './anthropic-file-support.js';
 export function buildProviderConfigs(settings) {
     const configs = [];
     if (settings.openaiApiKey) {
@@ -40,17 +40,14 @@ export function createAIProviderRegistry(configs, settings) {
                 providers['openai'] = createOpenAI({ apiKey: config.apiKey });
                 break;
             case 'anthropic':
-                providers['anthropic'] = createAnthropic({ apiKey: config.apiKey });
+                providers['anthropic'] = createAnthropicWithFileSupport(config.apiKey);
                 break;
             case 'google':
                 providers['google'] = createGoogleGenerativeAI({ apiKey: config.apiKey });
                 break;
             case 'openai-compatible':
                 if (config.baseUrl) {
-                    const customHeaders = settings?.openaiCompatibleHeaders?.reduce((acc, { header, value }) => {
-                        acc[header] = value;
-                        return acc;
-                    }, {}) ?? {};
+                    const customHeaders = Object.fromEntries(settings?.openaiCompatibleHeaders?.map(({ header, value }) => [header, value]) ?? []);
                     providers['openai-compatible'] = createOpenAICompatible({
                         name: settings?.openaiCompatibleName ?? 'openai-compatible',
                         apiKey: config.apiKey,

package/dist/ai/tools/fields/index.d.ts

@@ -29,7 +29,7 @@ export declare const FieldsValidateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     action: z.ZodLiteral<"update">;
     data: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
-        type: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
         children: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>, z.ZodNull]>>;
         collection: z.ZodOptional<z.ZodString>;
@@ -51,7 +51,7 @@ export declare const FieldsInputSchema: z.ZodObject<{
     collection: z.ZodOptional<z.ZodString>;
     field: z.ZodOptional<z.ZodString>;
     data: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        field: z.ZodOptional<z.ZodString>;
+        field: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
         type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         collection: z.ZodOptional<z.ZodOptional<z.ZodString>>;
@@ -87,7 +87,7 @@ export declare const fields: import("../types.js").ToolConfig<{
     action: "update";
     data: {
         field: string;
-        type: string;
+        type?: string | undefined;
         name?: string | undefined;
         children?: Record<string, any>[] | null | undefined;
         collection?: string | undefined;

package/dist/ai/tools/fields/index.js

@@ -28,7 +28,7 @@ export const FieldsValidateSchema = z.discriminatedUnion('action', [
     }),
     FieldsBaseValidateSchema.extend({
         action: z.literal('update'),
-        data: z.array(RawFieldItemValidateSchema),
+        data: z.array(RawFieldItemValidateSchema.partial({ type: true })),
     }),
     FieldsBaseValidateSchema.extend({
         action: z.literal('delete'),
@@ -38,11 +38,17 @@ export const FieldsValidateSchema = z.discriminatedUnion('action', [
 export const FieldsInputSchema = z.object({
     action: z.enum(['read', 'create', 'update', 'delete']).describe('The operation to perform'),
     collection: z.string().describe('The name of the collection').optional(),
-    field: z.string().optional(),
+    field: z
+        .string()
+        .describe('The name of the field. Required for delete. Optional for read (omit to read all fields). Do not use for create or update.')
+        .optional(),
     data: z
         .array(FieldItemInputSchema.extend({
         children: RawFieldItemInputSchema.shape.children,
-    }).partial())
+    })
+        .partial()
+        .required({ field: true }))
+        .describe('Array of field objects for create/update actions. Each object must include "field" (the field name).')
         .optional(),
 });
 export const fields = defineTool({