@directus/api 32.1.0 → 32.2.0

package/dist/ai/chat/constants/system-prompt.d.ts

@@ -0,0 +1 @@
+export declare const SYSTEM_PROMPT = "\n<behavior_instructions>\nYou are **Directus Assistant**, a Directus CMS expert with access to a Directus instance through specialized tools\n\n## Communication Style\n\n- **Be concise**: Users prefer short, direct responses. One-line confirmations: \"Created collection 'products'\"\n- **Match the audience**: Technical for developers, plain language for content editors\n- **NEVER guess**: If not at least 99% about field values or user intent, ask for clarification\n\n## Tool Usage Patterns\n\n### Discovery First\n\n1. Understand the user's task and what they need to achieve.\n2. Discover schema if needed for task - **schema()** with no params \u2192 lightweight collection list or **schema({ keys: [\"products\", \"categories\"] })** \u2192 full field/relation details\n3. Use other tools as needed to achieve the user's task.\n\n### Content Items\n\n- Use `fields` whenever possible to fetch only the exact fields you need\n- Use `filter` and `limit` to control the number of fetched items unless you absolutely need larger datasets\n- When presenting repeated structured data with 4+ items, use markdown tables for better readability\n\n### Schema & Data Changes\n\n- **Confirm before modifying any schema**: Collections, fields, relations always need approval from the user.\n- **Check namespace conflicts**: Collection folders and regular collections share namespace. Collection folders are\n  distinct from file folders.\n\n### Safety Rules\n\n- **Deletions require confirmation**: ALWAYS ask before deleting anything\n- **Warn on bulk operations**: Alert when affecting many items (\"This updates 500 items\")\n- **Avoid duplicates**: Never create duplicates if you can't modify existing items\n- **Use semantic HTML**: No classes, IDs, or inline styles in content fields (unless explicitly asked for by the user)\n- **Permission errors**: Report immediately, don't retry\n\n### Behavior Rules\n\n- Call tools immediately without explanatory text\n- Use parallel tool calls when possible\n- If you don't have access to a certain tool, ask the user to grant you access to the tool from the chat settings.\n- If there are unused tools in context but task is simple, suggest disabling unused tools (once per conversation)\n\n## Error Handling\n\n- Auto-retry once for clear errors (\"field X required\")\n- Stop after 2 failures, consult user\n- If tool unavailable, suggest enabling in chat settings\n</behavior_instructions>";

package/dist/ai/chat/constants/system-prompt.js

@@ -0,0 +1,51 @@
+export const SYSTEM_PROMPT = `
+<behavior_instructions>
+You are **Directus Assistant**, a Directus CMS expert with access to a Directus instance through specialized tools
+
+## Communication Style
+
+- **Be concise**: Users prefer short, direct responses. One-line confirmations: "Created collection 'products'"
+- **Match the audience**: Technical for developers, plain language for content editors
+- **NEVER guess**: If not at least 99% about field values or user intent, ask for clarification
+
+## Tool Usage Patterns
+
+### Discovery First
+
+1. Understand the user's task and what they need to achieve.
+2. Discover schema if needed for task - **schema()** with no params → lightweight collection list or **schema({ keys: ["products", "categories"] })** → full field/relation details
+3. Use other tools as needed to achieve the user's task.
+
+### Content Items
+
+- Use \`fields\` whenever possible to fetch only the exact fields you need
+- Use \`filter\` and \`limit\` to control the number of fetched items unless you absolutely need larger datasets
+- When presenting repeated structured data with 4+ items, use markdown tables for better readability
+
+### Schema & Data Changes
+
+- **Confirm before modifying any schema**: Collections, fields, relations always need approval from the user.
+- **Check namespace conflicts**: Collection folders and regular collections share namespace. Collection folders are
+  distinct from file folders.
+
+### Safety Rules
+
+- **Deletions require confirmation**: ALWAYS ask before deleting anything
+- **Warn on bulk operations**: Alert when affecting many items ("This updates 500 items")
+- **Avoid duplicates**: Never create duplicates if you can't modify existing items
+- **Use semantic HTML**: No classes, IDs, or inline styles in content fields (unless explicitly asked for by the user)
+- **Permission errors**: Report immediately, don't retry
+
+### Behavior Rules
+
+- Call tools immediately without explanatory text
+- Use parallel tool calls when possible
+- If you don't have access to a certain tool, ask the user to grant you access to the tool from the chat settings.
+- If there are unused tools in context but task is simple, suggest disabling unused tools (once per conversation)
+
+## Error Handling
+
+- Auto-retry once for clear errors ("field X required")
+- Stop after 2 failures, consult user
+- If tool unavailable, suggest enabling in chat settings
+</behavior_instructions>`;

package/dist/ai/chat/controllers/chat.post.d.ts

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

package/dist/ai/chat/controllers/chat.post.js

@@ -0,0 +1,47 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
+import { safeValidateUIMessages } from 'ai';
+import { fromZodError } from 'zod-validation-error';
+import { createUiStream } from '../lib/create-ui-stream.js';
+import { ChatRequest } from '../models/chat-request.js';
+import { chatRequestToolToAiSdkTool } from '../utils/chat-request-tool-to-ai-sdk-tool.js';
+import { fixErrorToolCalls } from '../utils/fix-error-tool-calls.js';
+export const aiChatPostHandler = async (req, res, _next) => {
+    if (!req.accountability?.app) {
+        throw new ForbiddenError();
+    }
+    const parseResult = ChatRequest.safeParse(req.body);
+    if (!parseResult.success) {
+        throw new InvalidPayloadError({ reason: fromZodError(parseResult.error).message });
+    }
+    const { provider, model, messages: rawMessages, tools: requestedTools, toolApprovals } = parseResult.data;
+    if (rawMessages.length === 0) {
+        throw new InvalidPayloadError({ reason: `"messages" must not be empty` });
+    }
+    const tools = requestedTools.reduce((acc, t) => {
+        const name = typeof t === 'string' ? t : t.name;
+        const aiTool = chatRequestToolToAiSdkTool({
+            chatRequestTool: t,
+            accountability: req.accountability,
+            schema: req.schema,
+            ...(toolApprovals && { toolApprovals }),
+        });
+        acc[name] = aiTool;
+        return acc;
+    }, {});
+    const fixedMessages = fixErrorToolCalls(rawMessages);
+    const validationResult = await safeValidateUIMessages({ messages: fixedMessages });
+    if (validationResult.success === false) {
+        throw new InvalidPayloadError({ reason: validationResult.error.message });
+    }
+    const stream = createUiStream(validationResult.data, {
+        provider,
+        model,
+        tools: tools,
+        apiKeys: res.locals['ai'].apiKeys,
+        systemPrompt: res.locals['ai'].systemPrompt,
+        onUsage: (usage) => {
+            res.write(`data: ${JSON.stringify({ type: 'data-usage', data: usage })}\n\n`);
+        },
+    });
+    stream.pipeUIMessageStreamToResponse(res);
+};

package/dist/ai/chat/lib/create-ui-stream.d.ts

@@ -0,0 +1,15 @@
+import { type LanguageModelUsage, type Tool, type UIMessage, type StreamTextResult } from 'ai';
+export interface CreateUiStreamOptions {
+    provider: 'openai' | 'anthropic';
+    model: string;
+    tools: {
+        [x: string]: Tool;
+    };
+    apiKeys: {
+        openai: string | null;
+        anthropic: string | null;
+    };
+    systemPrompt?: string;
+    onUsage?: (usage: Pick<LanguageModelUsage, 'inputTokens' | 'outputTokens' | 'totalTokens'>) => void | Promise<void>;
+}
+export declare const createUiStream: (messages: UIMessage[], { provider, model, tools, apiKeys, systemPrompt, onUsage }: CreateUiStreamOptions) => StreamTextResult<Record<string, Tool<any, any>>, any>;

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

@@ -0,0 +1,42 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { ServiceUnavailableError } from '@directus/errors';
+import { convertToModelMessages, stepCountIs, streamText, } from 'ai';
+import { SYSTEM_PROMPT } from '../constants/system-prompt.js';
+export const createUiStream = (messages, { provider, model, tools, apiKeys, systemPrompt, onUsage }) => {
+    if (apiKeys[provider] === null) {
+        throw new ServiceUnavailableError({ service: provider, reason: 'No API key configured for LLM provider' });
+    }
+    let modelProvider;
+    if (provider === 'openai') {
+        modelProvider = createOpenAI({ apiKey: apiKeys.openai });
+    }
+    else if (provider === 'anthropic') {
+        modelProvider = createAnthropic({ apiKey: apiKeys.anthropic });
+    }
+    else {
+        throw new Error(`Unexpected provider given: "${provider}"`);
+    }
+    systemPrompt ||= SYSTEM_PROMPT;
+    const stream = streamText({
+        system: systemPrompt,
+        model: modelProvider(model),
+        messages: convertToModelMessages(messages),
+        stopWhen: [stepCountIs(10)],
+        providerOptions: {
+            openai: {
+                reasoningSummary: 'auto',
+                store: false,
+                include: ['reasoning.encrypted_content'],
+            },
+        },
+        tools,
+        onFinish({ usage }) {
+            if (onUsage) {
+                const { inputTokens, outputTokens, totalTokens } = usage;
+                onUsage({ inputTokens, outputTokens, totalTokens });
+            }
+        },
+    });
+    return stream;
+};

package/dist/ai/chat/middleware/load-settings.d.ts

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

package/dist/ai/chat/middleware/load-settings.js

@@ -0,0 +1,18 @@
+import { SettingsService } from '../../../services/settings.js';
+import { getSchema } from '../../../utils/get-schema.js';
+export const loadSettings = async (_req, res, next) => {
+    const service = new SettingsService({
+        schema: await getSchema(),
+    });
+    const { ai_openai_api_key, ai_anthropic_api_key, ai_system_prompt } = await service.readSingleton({
+        fields: ['ai_openai_api_key', 'ai_anthropic_api_key', 'ai_system_prompt'],
+    });
+    res.locals['ai'] = {
+        apiKeys: {
+            openai: ai_openai_api_key,
+            anthropic: ai_anthropic_api_key,
+        },
+        systemPrompt: ai_system_prompt,
+    };
+    return next();
+};

package/dist/ai/chat/models/chat-request.d.ts

@@ -0,0 +1,34 @@
+import { type JSONSchema7 } from 'ai';
+import { z } from 'zod';
+export declare const ChatRequestTool: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodCustom<JSONSchema7, JSONSchema7>;
+}, z.core.$strip>]>;
+export type ChatRequestTool = z.infer<typeof ChatRequestTool>;
+export declare const ToolApprovalMode: z.ZodEnum<{
+    always: "always";
+    ask: "ask";
+    disabled: "disabled";
+}>;
+export type ToolApprovalMode = z.infer<typeof ToolApprovalMode>;
+export declare const ChatRequest: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    provider: z.ZodLiteral<"openai">;
+    model: z.ZodUnion<readonly [z.ZodLiteral<"gpt-5">, z.ZodLiteral<"gpt-5-nano">, z.ZodLiteral<"gpt-5-mini">, z.ZodLiteral<"gpt-5-pro">]>;
+}, z.core.$strip>, z.ZodObject<{
+    provider: z.ZodLiteral<"anthropic">;
+    model: z.ZodUnion<readonly [z.ZodLiteral<"claude-sonnet-4-5">, z.ZodLiteral<"claude-haiku-4-5">, z.ZodLiteral<"claude-opus-4-1">]>;
+}, z.core.$strip>], "provider">, z.ZodObject<{
+    tools: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodCustom<JSONSchema7, JSONSchema7>;
+    }, z.core.$strip>]>>;
+    messages: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+    toolApprovals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        always: "always";
+        ask: "ask";
+        disabled: "disabled";
+    }>>>;
+}, z.core.$strip>>;
+export type ChatRequest = z.infer<typeof ChatRequest>;

package/dist/ai/chat/models/chat-request.js

@@ -0,0 +1,26 @@
+import {} from 'ai';
+import { z } from 'zod';
+import { parseJsonSchema7 } from '../utils/parse-json-schema-7.js';
+import { ProviderAnthropic, ProviderOpenAi } from './providers.js';
+export const ChatRequestTool = z.union([
+    z.string(),
+    z.object({
+        name: z.string(),
+        description: z.string(),
+        inputSchema: z.custom((schema) => {
+            try {
+                parseJsonSchema7(schema);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }, { message: 'Invalid JSON schema' }),
+    }),
+]);
+export const ToolApprovalMode = z.enum(['always', 'ask', 'disabled']);
+export const ChatRequest = z.intersection(z.discriminatedUnion('provider', [ProviderOpenAi, ProviderAnthropic]), z.object({
+    tools: z.array(ChatRequestTool),
+    messages: z.array(z.looseObject({})),
+    toolApprovals: z.record(z.string(), ToolApprovalMode).optional(),
+}));

package/dist/ai/chat/models/providers.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const ProviderOpenAi: z.ZodObject<{
+    provider: z.ZodLiteral<"openai">;
+    model: z.ZodUnion<readonly [z.ZodLiteral<"gpt-5">, z.ZodLiteral<"gpt-5-nano">, z.ZodLiteral<"gpt-5-mini">, z.ZodLiteral<"gpt-5-pro">]>;
+}, z.core.$strip>;
+export declare const ProviderAnthropic: z.ZodObject<{
+    provider: z.ZodLiteral<"anthropic">;
+    model: z.ZodUnion<readonly [z.ZodLiteral<"claude-sonnet-4-5">, z.ZodLiteral<"claude-haiku-4-5">, z.ZodLiteral<"claude-opus-4-1">]>;
+}, z.core.$strip>;

package/dist/ai/chat/models/providers.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const ProviderOpenAi = z.object({
+    provider: z.literal('openai'),
+    model: z.union([z.literal('gpt-5'), z.literal('gpt-5-nano'), z.literal('gpt-5-mini'), z.literal('gpt-5-pro')]),
+});
+export const ProviderAnthropic = z.object({
+    provider: z.literal('anthropic'),
+    model: z.union([z.literal('claude-sonnet-4-5'), z.literal('claude-haiku-4-5'), z.literal('claude-opus-4-1')]),
+});

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

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

package/dist/ai/chat/router.js

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

package/dist/ai/chat/utils/chat-request-tool-to-ai-sdk-tool.d.ts

@@ -0,0 +1,9 @@
+import { type Accountability, type SchemaOverview } from '@directus/types';
+import type { Tool } from 'ai';
+import type { ChatRequestTool, ToolApprovalMode } from '../models/chat-request.js';
+export declare const chatRequestToolToAiSdkTool: ({ chatRequestTool, accountability, schema, toolApprovals, }: {
+    chatRequestTool: ChatRequestTool;
+    accountability: Accountability;
+    schema: SchemaOverview;
+    toolApprovals?: Record<string, ToolApprovalMode>;
+}) => Tool;

package/dist/ai/chat/utils/chat-request-tool-to-ai-sdk-tool.js

@@ -0,0 +1,38 @@
+import { InvalidPayloadError } from '@directus/errors';
+import {} from '@directus/types';
+import { jsonSchema, tool } from 'ai';
+import { fromZodError } from 'zod-validation-error';
+import { ALL_TOOLS } from '../../tools/index.js';
+export const chatRequestToolToAiSdkTool = ({ chatRequestTool, accountability, schema, toolApprovals, }) => {
+    if (typeof chatRequestTool === 'string') {
+        const directusTool = ALL_TOOLS.find(({ name }) => name === chatRequestTool);
+        if (!directusTool) {
+            throw new InvalidPayloadError({ reason: `Tool by name "${chatRequestTool}" does not exist` });
+        }
+        // Determine if tool needs approval based on client settings
+        // Default to 'ask' (needs approval) if not specified
+        const approvalMode = toolApprovals?.[chatRequestTool] ?? 'ask';
+        const needsApproval = approvalMode !== 'always';
+        return tool({
+            name: directusTool.name,
+            description: directusTool.description,
+            inputSchema: directusTool.inputSchema,
+            needsApproval,
+            execute: async (rawArgs) => {
+                const { error, data: args } = directusTool.validateSchema?.safeParse(rawArgs) ?? {
+                    data: rawArgs,
+                };
+                if (error) {
+                    throw new InvalidPayloadError({ reason: fromZodError(error).message });
+                }
+                return directusTool.handler({ args, accountability, schema });
+            },
+        });
+    }
+    // Local/client-side tool (schema only, executed on client)
+    return tool({
+        name: chatRequestTool.name,
+        description: chatRequestTool.description,
+        inputSchema: jsonSchema(chatRequestTool.inputSchema),
+    });
+};

package/dist/ai/chat/utils/fix-error-tool-calls.d.ts

@@ -0,0 +1,12 @@
+import type { UIMessage } from 'ai';
+/**
+ * Fixes tool calls with error states by copying rawInput to input field.
+ * This is required because error tool calls from the frontend use rawInput
+ * but the AI SDK's convertToModelMessages expects input to generate arguments
+ * for the OpenAI API.
+ * @param messages - Array of message objects from the chat request
+ * @returns Messages with error tool calls fixed, typed as UIMessage[]
+ */
+export declare const fixErrorToolCalls: (messages: {
+    [x: string]: unknown;
+}[]) => UIMessage[];

package/dist/ai/chat/utils/fix-error-tool-calls.js

@@ -0,0 +1,30 @@
+/**
+ * Fixes tool calls with error states by copying rawInput to input field.
+ * This is required because error tool calls from the frontend use rawInput
+ * but the AI SDK's convertToModelMessages expects input to generate arguments
+ * for the OpenAI API.
+ * @param messages - Array of message objects from the chat request
+ * @returns Messages with error tool calls fixed, typed as UIMessage[]
+ */
+export const fixErrorToolCalls = (messages) => {
+    return messages.map((msg) => {
+        if (msg['role'] === 'assistant' && msg['parts'] && Array.isArray(msg['parts'])) {
+            const fixedParts = msg['parts'].map((part) => {
+                if (typeof part === 'object' &&
+                    part !== null &&
+                    'type' in part &&
+                    typeof part.type === 'string' &&
+                    part.type.startsWith('tool-') &&
+                    'state' in part &&
+                    part.state === 'output-error' &&
+                    'rawInput' in part &&
+                    (!('input' in part) || part.input == null)) {
+                    return { ...part, input: part.rawInput };
+                }
+                return part;
+            });
+            return { ...msg, parts: fixedParts };
+        }
+        return msg;
+    });
+};

package/dist/ai/chat/utils/parse-json-schema-7.d.ts

@@ -0,0 +1,13 @@
+import type { JSONSchema7 } from 'ai';
+/**
+ * Checks whether an input object is *likely* a JSON Schema 7 object
+ * Limitations:
+ * - Does NOT validate nested schemas (e.g., inside `properties`, `items`, `definitions`, etc.)
+ * - Does NOT check for correct usage of combinators (`anyOf`, `allOf`, `oneOf`, `not`)
+ * - Does NOT verify required/optional keyword relationships (e.g., `required` only valid for object type)
+ * - Does NOT validate formats, patterns, or constraints (e.g., `pattern`, `minimum`, `maximum`, etc.)
+ * - Accepts both `definitions` and `$defs` for tolerance, but does not enforce draft-07 strictness
+ * - Only checks for presence of top-level schema keywords
+ * This is not a perfect validator, and does not check nested properties or full JSON Schema 7 compliance
+ */
+export declare const parseJsonSchema7: (schema: unknown) => JSONSchema7;

package/dist/ai/chat/utils/parse-json-schema-7.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { fromZodError } from 'zod-validation-error';
+const jsonType = z.enum(['null', 'boolean', 'object', 'array', 'number', 'integer', 'string']);
+const maybeDraft7Url = z.url({ protocol: /^https?$/, hostname: /^json-schema\.org$/ }).refine((val) => {
+    try {
+        const u = new URL(val);
+        return u.pathname === '/draft-07/schema' && (u.hash === '' || u.hash === '#');
+    }
+    catch {
+        return false;
+    }
+}, { message: 'Must be the JSON Schema Draft-07 meta-schema URL' });
+const JsonSchema7 = z
+    .object({
+    $schema: maybeDraft7Url.optional(),
+    $id: z.string().optional(),
+    $ref: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    // common keywords
+    type: z.union([jsonType, z.array(jsonType).nonempty()]).optional(),
+    properties: z.record(z.string(), z.any()).optional(),
+    required: z.array(z.string()).optional(),
+    items: z.union([z.any(), z.array(z.any()).nonempty()]).optional(),
+    additionalProperties: z.union([z.boolean(), z.any()]).optional(),
+    patternProperties: z.record(z.string(), z.any()).optional(),
+    enum: z.array(z.any()).optional(),
+    const: z.any().optional(),
+    anyOf: z.array(z.any()).optional(),
+    allOf: z.array(z.any()).optional(),
+    oneOf: z.array(z.any()).optional(),
+    not: z.any().optional(),
+    // draft-07 naming; accept both for tolerance
+    definitions: z.record(z.string(), z.any()).optional(),
+    $defs: z.record(z.string(), z.any()).optional(), // not draft-07, but appears in newer drafts
+})
+    .refine((obj) => {
+    const keys = new Set(Object.keys(obj));
+    const schemaish = [
+        'type',
+        'properties',
+        'items',
+        'required',
+        'enum',
+        'const',
+        'anyOf',
+        'allOf',
+        'oneOf',
+        'not',
+        '$ref',
+        'additionalProperties',
+        'patternProperties',
+        'definitions',
+        '$defs',
+    ];
+    return schemaish.some((k) => keys.has(k));
+}, { message: 'No schema keywords found' });
+/**
+ * Checks whether an input object is *likely* a JSON Schema 7 object
+ * Limitations:
+ * - Does NOT validate nested schemas (e.g., inside `properties`, `items`, `definitions`, etc.)
+ * - Does NOT check for correct usage of combinators (`anyOf`, `allOf`, `oneOf`, `not`)
+ * - Does NOT verify required/optional keyword relationships (e.g., `required` only valid for object type)
+ * - Does NOT validate formats, patterns, or constraints (e.g., `pattern`, `minimum`, `maximum`, etc.)
+ * - Accepts both `definitions` and `$defs` for tolerance, but does not enforce draft-07 strictness
+ * - Only checks for presence of top-level schema keywords
+ * This is not a perfect validator, and does not check nested properties or full JSON Schema 7 compliance
+ */
+export const parseJsonSchema7 = (schema) => {
+    const { success, error, data } = JsonSchema7.safeParse(schema);
+    if (!success) {
+        throw new Error(`Invalid JSON Schema passed: ${fromZodError(error).message}`);
+    }
+    return data;
+};

package/dist/{mcp → ai/mcp}/server.d.ts

@@ -1,7 +1,8 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { type GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
 import type { Request, Response } from 'express';
-import type { MCPOptions, ToolConfig, ToolResult } from './types.js';
+import type { ToolConfig, ToolResult } from '../tools/types.js';
+import type { MCPOptions } from './types.js';
 export declare class DirectusMCP {
     promptsCollection?: string | null;
     systemPrompt?: string | null;
@@ -22,60 +23,52 @@ export declare class DirectusMCP {
     toToolResponse(result?: ToolResult): {
         [x: string]: unknown;
         content: ({
-            [x: string]: unknown;
             type: "text";
             text: string;
             _meta?: {
                 [x: string]: unknown;
             } | undefined;
         } | {
-            [x: string]: unknown;
-            data: string;
             type: "image";
+            data: string;
             mimeType: string;
             _meta?: {
                 [x: string]: unknown;
             } | undefined;
         } | {
-            [x: string]: unknown;
-            data: string;
             type: "audio";
+            data: string;
             mimeType: string;
             _meta?: {
                 [x: string]: unknown;
             } | undefined;
         } | {
-            [x: string]: unknown;
-            type: "resource_link";
-            name: string;
             uri: string;
+            name: string;
+            type: "resource_link";
             description?: string | undefined;
-            title?: string | undefined;
             mimeType?: string | undefined;
             _meta?: {
                 [x: string]: unknown;
             } | undefined;
             icons?: {
-                [x: string]: unknown;
                 src: string;
                 mimeType?: string | undefined;
                 sizes?: string[] | undefined;
             }[] | undefined;
+            title?: string | undefined;
         } | {
-            [x: string]: unknown;
             type: "resource";
             resource: {
-                [x: string]: unknown;
-                text: string;
                 uri: string;
+                text: string;
                 mimeType?: string | undefined;
                 _meta?: {
                     [x: string]: unknown;
                 } | undefined;
             } | {
-                [x: string]: unknown;
-                blob: string;
                 uri: string;
+                blob: string;
                 mimeType?: string | undefined;
                 _meta?: {
                     [x: string]: unknown;
@@ -87,6 +80,10 @@ export declare class DirectusMCP {
         })[];
         _meta?: {
             [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
         } | undefined;
         structuredContent?: {
             [x: string]: unknown;

package/dist/{mcp → ai/mcp}/server.js

@@ -6,10 +6,9 @@ import { CallToolRequestSchema, GetPromptRequestSchema, InitializedNotificationS
 import { render, tokenize } from 'micromustache';
 import { z } from 'zod';
 import { fromZodError } from 'zod-validation-error';
-import { ItemsService } from '../services/index.js';
-import { sanitizeQuery } from '../utils/sanitize-query.js';
-import { Url } from '../utils/url.js';
-import { findMcpTool, getAllMcpTools } from './tools/index.js';
+import { ItemsService } from '../../services/index.js';
+import { Url } from '../../utils/url.js';
+import { findMcpTool, getAllMcpTools } from '../tools/index.js';
 import { DirectusTransport } from './transport.js';
 export class DirectusMCP {
     promptsCollection;
@@ -167,7 +166,6 @@ export class DirectusMCP {
         // calling tools
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const tool = findMcpTool(request.params.name);
-            let sanitizedQuery = {};
             try {
                 if (!tool || (tool.name === 'system-prompt' && this.systemPromptEnabled === false)) {
                     throw new InvalidPayloadError({ reason: `"${request.params.name}" doesn't exist in the toolset` });
@@ -196,18 +194,11 @@ export class DirectusMCP {
                 if (!isObject(args)) {
                     throw new InvalidPayloadError({ reason: '"arguments" must be an object' });
                 }
-                if ('action' in args && args['action'] === 'delete' && !this.allowDeletes) {
+                if (this.allowDeletes === false && 'action' in args && args['action'] === 'delete') {
                     throw new InvalidPayloadError({ reason: 'Delete actions are disabled' });
                 }
-                if ('query' in args && args['query']) {
-                    sanitizedQuery = await sanitizeQuery({
-                        fields: args['query']['fields'] || '*',
-                        ...args['query'],
-                    }, req.schema, req.accountability);
-                }
                 const result = await tool.handler({
                     args,
-                    sanitizedQuery,
                     schema: req.schema,
                     accountability: req.accountability,
                 });

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

@@ -0,0 +1,15 @@
+export interface Prompt {
+    name: string;
+    system_prompt?: string | null;
+    description?: string;
+    messages: {
+        role: 'user' | 'assistant';
+        text: string;
+    }[];
+}
+export interface MCPOptions {
+    promptsCollection?: string;
+    allowDeletes?: boolean;
+    systemPromptEnabled?: boolean;
+    systemPrompt?: string | null;
+}

package/dist/{mcp/tools/assets.js → ai/tools/assets/index.js}

@@ -1,9 +1,12 @@
 import { UnsupportedMediaTypeError } from '@directus/errors';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
-import { AssetsService } from '../../services/assets.js';
-import { FilesService } from '../../services/files.js';
-import { defineTool } from '../define.js';
-import prompts from './prompts/index.js';
+import { AssetsService } from '../../../services/assets.js';
+import { FilesService } from '../../../services/files.js';
+import { requireText } from '../../../utils/require-text.js';
+import { defineTool } from '../define-tool.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const AssetsValidateSchema = z.strictObject({
     id: z.string(),
 });
@@ -12,7 +15,7 @@ const AssetsInputSchema = z.object({
 });
 export const assets = defineTool({
     name: 'assets',
-    description: prompts.assets,
+    description: requireText(resolve(__dirname, './prompt.md')),
     annotations: {
         title: 'Directus - Assets',
     },