strapi-plugin-ai-sdk 0.2.0

package/dist/server/index.mjs

@@ -0,0 +1,1712 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { generateText, streamText, tool, zodSchema, convertToModelMessages, stepCountIs } from "ai";
+import { z } from "zod";
+import { PassThrough, Readable } from "node:stream";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function createMcpServer(strapi) {
+  const plugin = strapi.plugin("ai-sdk");
+  const registry = plugin.toolRegistry;
+  if (!registry) {
+    throw new Error("Tool registry not initialized");
+  }
+  const server = new McpServer(
+    {
+      name: "ai-sdk-mcp",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  const toolNames = [];
+  for (const [name, def] of registry.getPublic()) {
+    const mcpName = toSnakeCase(name);
+    toolNames.push(mcpName);
+    server.registerTool(
+      mcpName,
+      {
+        description: def.description,
+        inputSchema: def.schema.shape
+      },
+      async (args) => {
+        strapi.log.debug(`[ai-sdk:mcp] Tool call: ${mcpName}`);
+        const result = await def.execute(args, strapi);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  }
+  strapi.log.info("[ai-sdk:mcp] MCP server created with tools:", { tools: toolNames });
+  return server;
+}
+const MAX_CHARS = 2e3;
+function chunkText(text, maxLen) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > maxLen) {
+    const slice = remaining.slice(0, maxLen);
+    const match = slice.match(/.*[.!?](\s|$)/);
+    const splitAt = match ? match[0].length : maxLen;
+    chunks.push(remaining.slice(0, splitAt).trim());
+    remaining = remaining.slice(splitAt).trim();
+  }
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}
+class TypecastProvider {
+  constructor(apiKey, actorId) {
+    this.apiKey = apiKey;
+    this.actorId = actorId;
+  }
+  async synthesize(text, options2) {
+    const chunks = chunkText(text, MAX_CHARS);
+    const buffers = [];
+    for (const chunk of chunks) {
+      const buf = await this.synthesizeChunk(chunk, options2);
+      buffers.push(buf);
+    }
+    return Buffer.concat(buffers);
+  }
+  async synthesizeChunk(text, options2) {
+    const body = {
+      text,
+      voice_id: this.actorId,
+      model: "ssfm-v30",
+      lang: "auto"
+    };
+    if (options2?.emotion) {
+      body.emotion = options2.emotion;
+    }
+    if (options2?.speed !== void 0) {
+      body.speed = options2.speed;
+    }
+    const response = await fetch("https://api.typecast.ai/v1/text-to-speech", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-KEY": this.apiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`Typecast API error ${response.status}: ${errorText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+}
+class TTSRegistry {
+  constructor() {
+    this.factories = /* @__PURE__ */ new Map();
+  }
+  register(name, factory) {
+    this.factories.set(name, factory);
+  }
+  create(name, config2) {
+    const factory = this.factories.get(name);
+    if (!factory) {
+      throw new Error(`Unknown TTS provider: "${name}". Registered: ${[...this.factories.keys()].join(", ") || "none"}`);
+    }
+    return factory(config2);
+  }
+  has(name) {
+    return this.factories.has(name);
+  }
+}
+function createTTSRegistry() {
+  const registry = new TTSRegistry();
+  registry.register("typecast", (config2) => {
+    const apiKey = config2.apiKey;
+    const actorId = config2.actorId;
+    if (!apiKey || !actorId) {
+      throw new Error("Typecast TTS requires apiKey and actorId");
+    }
+    return new TypecastProvider(apiKey, actorId);
+  });
+  return registry;
+}
+const DEFAULT_MODEL = "claude-sonnet-4-20250514";
+const DEFAULT_TEMPERATURE = 0.7;
+function isPromptInput(input) {
+  return "prompt" in input;
+}
+class AIProvider {
+  constructor() {
+    this.modelFactory = null;
+    this.model = DEFAULT_MODEL;
+  }
+  static {
+    this.providerRegistry = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a named provider creator.
+   * Call this before initialize() — typically in bootstrap.
+   */
+  static registerProvider(name, creator) {
+    AIProvider.providerRegistry.set(name, creator);
+  }
+  /**
+   * Initialize the provider with plugin configuration.
+   * Returns false if config is missing required fields.
+   */
+  initialize(config2) {
+    const cfg = config2;
+    if (!cfg?.anthropicApiKey) {
+      return false;
+    }
+    const providerName = cfg.provider ?? "anthropic";
+    const creator = AIProvider.providerRegistry.get(providerName);
+    if (!creator) {
+      throw new Error(
+        `AI provider "${providerName}" not registered. Registered: ${[...AIProvider.providerRegistry.keys()].join(", ") || "none"}. Register providers in bootstrap before initializing.`
+      );
+    }
+    this.modelFactory = creator({ apiKey: cfg.anthropicApiKey, baseURL: cfg.baseURL });
+    if (cfg.chatModel) {
+      this.model = cfg.chatModel;
+    }
+    return true;
+  }
+  getLanguageModel() {
+    if (!this.modelFactory) {
+      throw new Error("AIProvider not initialized");
+    }
+    return this.modelFactory(this.model);
+  }
+  buildParams(input) {
+    const base = {
+      model: this.getLanguageModel(),
+      system: input.system,
+      temperature: input.temperature ?? DEFAULT_TEMPERATURE,
+      maxOutputTokens: input.maxOutputTokens,
+      tools: input.tools,
+      stopWhen: input.stopWhen
+    };
+    return isPromptInput(input) ? { ...base, prompt: input.prompt } : { ...base, messages: input.messages };
+  }
+  async generate(input) {
+    const result = await generateText(this.buildParams(input));
+    return { text: result.text };
+  }
+  async stream(input) {
+    const result = streamText(this.buildParams(input));
+    return { textStream: result.textStream };
+  }
+  /**
+   * Returns the raw streamText result for use with toUIMessageStreamResponse().
+   * Compatible with AI SDK UI hooks (useChat, useCompletion).
+   */
+  streamRaw(input) {
+    return streamText(this.buildParams(input));
+  }
+  // Convenience methods for simple prompt-based calls
+  async generateText(prompt, options2) {
+    return this.generate({ prompt, ...options2 });
+  }
+  async streamText(prompt, options2) {
+    return this.stream({ prompt, ...options2 });
+  }
+  getChatModel() {
+    return this.model;
+  }
+  isInitialized() {
+    return this.modelFactory !== null;
+  }
+  destroy() {
+    this.modelFactory = null;
+  }
+}
+class ToolRegistry {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  register(def) {
+    this.tools.set(def.name, def);
+  }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  /** All registered tools (internal + public) */
+  getAll() {
+    return new Map(this.tools);
+  }
+  /** Only tools that should be exposed via MCP (non-internal) */
+  getPublic() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, def] of this.tools) {
+      if (!def.internal) {
+        result.set(name, def);
+      }
+    }
+    return result;
+  }
+}
+const listContentTypesSchema = z.object({});
+const listContentTypesDescription = "List all Strapi content types and components with their fields, relations, and structure.";
+const INTERNAL_FIELDS = /* @__PURE__ */ new Set([
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "locale",
+  "localizations"
+]);
+function isApiContentType(uid) {
+  return !uid.startsWith("admin::") && !uid.startsWith("strapi::");
+}
+function extractRelation(attrName, attr, contentTypes2) {
+  if (attr.type !== "relation" || !attr.target) return null;
+  const target = attr.target;
+  const relation = attr.relation;
+  const targetCt = contentTypes2[target];
+  return {
+    field: attrName,
+    type: relation,
+    target,
+    targetDisplayName: targetCt?.info?.displayName || target
+  };
+}
+function collectComponents(attr) {
+  if (attr.type === "component" && attr.component) {
+    return [attr.component];
+  }
+  if (attr.type === "dynamiczone" && Array.isArray(attr.components)) {
+    return attr.components;
+  }
+  return [];
+}
+function parseContentType(uid, contentType, allContentTypes) {
+  const ct = contentType;
+  const fields = [];
+  const relations = [];
+  const usedComponents = /* @__PURE__ */ new Set();
+  for (const [attrName, attrDef] of Object.entries(ct.attributes || {})) {
+    if (INTERNAL_FIELDS.has(attrName)) continue;
+    fields.push(attrName);
+    const relation = extractRelation(attrName, attrDef, allContentTypes);
+    if (relation) relations.push(relation);
+    for (const comp of collectComponents(attrDef)) {
+      usedComponents.add(comp);
+    }
+  }
+  return {
+    uid,
+    kind: ct.kind || "collectionType",
+    displayName: ct.info?.displayName || uid,
+    fields,
+    relations,
+    components: [...usedComponents]
+  };
+}
+function parseComponent(uid, component) {
+  const comp = component;
+  return {
+    uid,
+    category: comp.category || "default",
+    displayName: comp.info?.displayName || uid,
+    fieldCount: Object.keys(comp.attributes || {}).length
+  };
+}
+async function listContentTypes(strapi) {
+  const contentTypes2 = Object.entries(strapi.contentTypes).filter(([uid]) => isApiContentType(uid)).map(([uid, ct]) => parseContentType(uid, ct, strapi.contentTypes)).sort((a, b) => a.displayName.localeCompare(b.displayName));
+  const components = Object.entries(strapi.components).map(([uid, comp]) => parseComponent(uid, comp)).sort((a, b) => a.category.localeCompare(b.category) || a.displayName.localeCompare(b.displayName));
+  return { contentTypes: contentTypes2, components };
+}
+const MAX_PAGE_SIZE = 50;
+const searchContentSchema = z.object({
+  contentType: z.string().describe(
+    'The content type UID to search, e.g. "api::article.article" or "plugin::users-permissions.user"'
+  ),
+  query: z.string().optional().describe("Full-text search query string (searches across all searchable text fields)"),
+  filters: z.record(z.string(), z.unknown()).optional().describe('Strapi filter object, e.g. { username: { $containsi: "john" } }'),
+  fields: z.array(z.string()).optional().describe("Specific fields to return. If omitted, returns all fields."),
+  sort: z.string().optional().describe('Sort order, e.g. "createdAt:desc"'),
+  page: z.number().optional().default(1).describe("Page number (starts at 1)"),
+  pageSize: z.number().optional().default(10).describe(`Results per page (max ${MAX_PAGE_SIZE})`)
+});
+const searchContentDescription = "Search and query any Strapi content type. Use listContentTypes first to discover available content types and their fields, then use this tool to query specific collections.";
+async function searchContent(strapi, params) {
+  const { contentType, query, filters, fields, sort, page = 1, pageSize = 10 } = params;
+  if (!strapi.contentTypes[contentType]) {
+    throw new Error(`Content type "${contentType}" does not exist.`);
+  }
+  const clampedPageSize = Math.min(pageSize, MAX_PAGE_SIZE);
+  const results = await strapi.documents(contentType).findMany({
+    ...query ? { _q: query } : {},
+    ...filters ? { filters } : {},
+    ...fields ? { fields } : {},
+    ...sort ? { sort } : {},
+    page,
+    pageSize: clampedPageSize,
+    populate: "*"
+  });
+  const total = await strapi.documents(contentType).count({
+    ...query ? { _q: query } : {},
+    ...filters ? { filters } : {}
+  });
+  return {
+    results,
+    pagination: {
+      page,
+      pageSize: clampedPageSize,
+      total
+    }
+  };
+}
+const writeContentSchema = z.object({
+  contentType: z.string().describe('Content type UID, e.g. "api::article.article"'),
+  action: z.enum(["create", "update"]).describe("Whether to create a new document or update an existing one"),
+  documentId: z.string().optional().describe("Required for update — the document ID to update"),
+  data: z.record(z.string(), z.unknown()).describe("The field values to set. Must match the content type schema."),
+  status: z.enum(["draft", "published"]).optional().describe("Document status. Defaults to draft.")
+});
+const writeContentDescription = "Create or update a document in any Strapi content type. Use listContentTypes first to discover the schema, and searchContent to find existing documents for updates.";
+async function writeContent(strapi, params) {
+  const { contentType, action, documentId, data, status } = params;
+  if (!strapi.contentTypes[contentType]) {
+    throw new Error(`Content type "${contentType}" does not exist.`);
+  }
+  if (action === "update" && !documentId) {
+    throw new Error("documentId is required for update actions.");
+  }
+  const docs = strapi.documents(contentType);
+  if (action === "create") {
+    const document2 = await docs.create({
+      data,
+      ...status ? { status } : {},
+      populate: "*"
+    });
+    return { action: "create", document: document2 };
+  }
+  const document = await docs.update({
+    documentId,
+    data,
+    ...status ? { status } : {},
+    populate: "*"
+  });
+  return { action: "update", document };
+}
+const sendEmailSchema = z.object({
+  to: z.string().describe("Recipient email address"),
+  subject: z.string().describe("Email subject line"),
+  html: z.string().describe("Email body as HTML"),
+  text: z.string().optional().describe("Plain text fallback (optional, derived from html if omitted)"),
+  cc: z.string().optional().describe("CC email address (optional)"),
+  bcc: z.string().optional().describe("BCC email address (optional)"),
+  replyTo: z.string().optional().describe("Reply-to email address (optional)")
+});
+const sendEmailDescription = "Send an email using the configured email provider. Compose the email content as HTML. IMPORTANT: Before calling this tool, you MUST confirm the recipient email address with the user by repeating it back and asking for explicit approval. Always use the exact recipient email address the user specifies — never substitute it with a default or admin email. Also confirm the subject and body before sending.";
+async function sendEmail(strapi, params) {
+  const emailPlugin = strapi.plugin("email");
+  if (!emailPlugin) {
+    return {
+      success: false,
+      message: "The email plugin is not installed or enabled. Install @strapi/plugin-email and configure an email provider (e.g. strapi-provider-email-resend).",
+      to: params.to,
+      subject: params.subject
+    };
+  }
+  try {
+    await emailPlugin.service("email").send({
+      to: params.to,
+      subject: params.subject,
+      html: params.html,
+      text: params.text,
+      cc: params.cc,
+      bcc: params.bcc,
+      replyTo: params.replyTo
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const isDomainError = /not allowed|verify|domain|can only send/i.test(detail);
+    const hint = isDomainError ? " This usually means the sending domain is not verified in Resend. In test mode, emails can only be delivered to the account owner's address. Verify your domain at https://resend.com/domains to send to any recipient." : "";
+    return {
+      success: false,
+      message: `Failed to send email to ${params.to}: ${detail}.${hint}`,
+      to: params.to,
+      subject: params.subject
+    };
+  }
+  return {
+    success: true,
+    message: `Email successfully sent to ${params.to} with subject "${params.subject}".`,
+    to: params.to,
+    subject: params.subject
+  };
+}
+const CONTENT_TYPE$3 = "plugin::ai-sdk.memory";
+const saveMemorySchema = z.object({
+  content: z.string().describe('A short, factual statement to remember about the user (e.g. "User prefers dark mode", "Company name is Acme Corp")'),
+  category: z.string().optional().describe('Category for the memory (e.g. "preference", "project", "personal", "general"). Defaults to "general".')
+});
+const saveMemoryDescription = "Save a fact or preference about the user to long-term memory. Use this proactively when the user shares personal information, preferences, or important context that would be useful in future conversations. Keep each memory concise and factual.";
+async function saveMemory(strapi, params, context) {
+  if (!context?.adminUserId) {
+    return { success: false, message: "Cannot save memory: user context not available." };
+  }
+  try {
+    await strapi.documents(CONTENT_TYPE$3).create({
+      data: {
+        content: params.content,
+        category: params.category || "general",
+        adminUserId: context.adminUserId
+      }
+    });
+    return { success: true, message: `Memory saved: "${params.content}"` };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, message: `Failed to save memory: ${detail}` };
+  }
+}
+const CONTENT_TYPE$2 = "plugin::ai-sdk.memory";
+const recallMemoriesSchema = z.object({
+  query: z.string().optional().describe("Optional search term to filter memories by content"),
+  category: z.string().optional().describe('Optional category to filter by (e.g. "preference", "project", "personal")')
+});
+const recallMemoriesDescription = "Recall saved memories/facts about the user. Use this to look up previously saved information. Without parameters, returns all memories.";
+async function recallMemories(strapi, params, context) {
+  if (!context?.adminUserId) {
+    return { success: false, memories: [], count: 0 };
+  }
+  try {
+    const filters = { adminUserId: context.adminUserId };
+    if (params.category) {
+      filters.category = params.category;
+    }
+    if (params.query) {
+      filters.content = { $containsi: params.query };
+    }
+    const memories = await strapi.documents(CONTENT_TYPE$2).findMany({
+      filters,
+      fields: ["content", "category"],
+      sort: { createdAt: "desc" }
+    });
+    return {
+      success: true,
+      memories: memories.map((m) => ({ content: m.content, category: m.category })),
+      count: memories.length
+    };
+  } catch (error) {
+    return { success: false, memories: [], count: 0 };
+  }
+}
+const listContentTypesTool = {
+  name: "listContentTypes",
+  description: listContentTypesDescription,
+  schema: listContentTypesSchema,
+  execute: async (_args, strapi) => listContentTypes(strapi)
+};
+const searchContentTool = {
+  name: "searchContent",
+  description: searchContentDescription,
+  schema: searchContentSchema,
+  execute: async (args, strapi) => searchContent(strapi, args)
+};
+async function sanitizeOutput(strapi, uid, data, auth) {
+  if (!data) return data;
+  const contentType = strapi.contentType(uid);
+  if (!contentType) {
+    throw new Error(`Content type "${uid}" not found. Cannot sanitize output.`);
+  }
+  try {
+    return await strapi.contentAPI.sanitize.output(data, contentType, { auth });
+  } catch (error) {
+    strapi.log.error("[ai-sdk:mcp] Output sanitization failed", {
+      uid,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    throw error;
+  }
+}
+async function sanitizeInput(strapi, uid, data, auth) {
+  if (!data) return data;
+  const contentType = strapi.contentType(uid);
+  if (!contentType) {
+    throw new Error(`Content type "${uid}" not found. Cannot sanitize input.`);
+  }
+  try {
+    return await strapi.contentAPI.sanitize.input(data, contentType, { auth });
+  } catch (error) {
+    strapi.log.error("[ai-sdk:mcp] Input sanitization failed", {
+      uid,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    throw error;
+  }
+}
+const writeContentTool = {
+  name: "writeContent",
+  description: writeContentDescription,
+  schema: writeContentSchema,
+  execute: async (args, strapi) => {
+    const sanitizedData = await sanitizeInput(strapi, args.contentType, args.data);
+    const result = await writeContent(strapi, { ...args, data: sanitizedData });
+    const sanitizedDoc = await sanitizeOutput(strapi, args.contentType, result.document);
+    return { ...result, document: sanitizedDoc };
+  }
+};
+const triggerAnimationTool = {
+  name: "triggerAnimation",
+  description: [
+    "Trigger a 3D avatar animation on the client. ALWAYS call this at the start of every response.",
+    "Available animations and when to use them:",
+    "- speak: DEFAULT — use this for all normal responses (head nods, arm gestures, like talking)",
+    "- wave: greeting the user or saying hello/goodbye",
+    "- nod: agreeing, confirming, or acknowledging something",
+    "- think: considering a question, pondering, or working through a problem",
+    "- celebrate: task completed successfully, good news, or congratulations",
+    "- shake: disagreeing, saying no, or indicating something is wrong",
+    "- spin: when the user asks you to spin or do a twirl",
+    "- idle: return to default resting pose",
+    'When in doubt, use "speak". Use specific animations only for strong emotional moments.'
+  ].join("\n"),
+  schema: z.object({
+    animation: z.enum(["idle", "speak", "wave", "nod", "think", "celebrate", "shake", "spin"]).describe("The animation to play on the 3D avatar")
+  }),
+  execute: async ({ animation }) => ({ triggered: animation, status: "playing" }),
+  internal: true
+};
+const sendEmailTool = {
+  name: "sendEmail",
+  description: sendEmailDescription,
+  schema: sendEmailSchema,
+  execute: async (args, strapi) => sendEmail(strapi, args),
+  internal: false
+};
+const saveMemoryTool = {
+  name: "saveMemory",
+  description: saveMemoryDescription,
+  schema: saveMemorySchema,
+  execute: async (args, strapi, context) => saveMemory(strapi, args, context),
+  internal: true
+};
+const recallMemoriesTool = {
+  name: "recallMemories",
+  description: recallMemoriesDescription,
+  schema: recallMemoriesSchema,
+  execute: async (args, strapi, context) => recallMemories(strapi, args, context),
+  internal: true
+};
+const builtInTools = [
+  listContentTypesTool,
+  searchContentTool,
+  writeContentTool,
+  triggerAnimationTool,
+  sendEmailTool,
+  saveMemoryTool,
+  recallMemoriesTool
+];
+const PLUGIN_ID$3 = "ai-sdk";
+const bootstrap = ({ strapi }) => {
+  const plugin = strapi.plugin(PLUGIN_ID$3);
+  const config2 = strapi.config.get(`plugin::${PLUGIN_ID$3}`);
+  AIProvider.registerProvider("anthropic", ({ apiKey, baseURL }) => {
+    const provider = createAnthropic({ apiKey, baseURL });
+    return (modelId) => provider(modelId);
+  });
+  const aiProvider = new AIProvider();
+  const initialized = aiProvider.initialize(config2);
+  if (initialized) {
+    plugin.aiProvider = aiProvider;
+    strapi.log.info(`[${PLUGIN_ID$3}] AI provider initialized with model: ${aiProvider.getChatModel()}`);
+  } else {
+    strapi.log.warn(`[${PLUGIN_ID$3}] anthropicApiKey not configured, AI provider will not be available`);
+  }
+  const toolRegistry = new ToolRegistry();
+  for (const tool2 of builtInTools) {
+    toolRegistry.register(tool2);
+  }
+  plugin.toolRegistry = toolRegistry;
+  plugin.createMcpServer = () => createMcpServer(strapi);
+  plugin.mcpSessions = /* @__PURE__ */ new Map();
+  const ttsRegistry = createTTSRegistry();
+  plugin.ttsRegistry = ttsRegistry;
+  if (config2.typecastApiKey && config2.typecastActorId) {
+    plugin.ttsProvider = ttsRegistry.create("typecast", {
+      apiKey: config2.typecastApiKey,
+      actorId: config2.typecastActorId
+    });
+    strapi.log.info(`[${PLUGIN_ID$3}] TTS provider initialized (typecast)`);
+  }
+  strapi.log.info(`[${PLUGIN_ID$3}] MCP endpoint available at: /api/${PLUGIN_ID$3}/mcp`);
+};
+const PLUGIN_ID$2 = "ai-sdk";
+async function closeSession(strapi, sessionId, session) {
+  try {
+    if (session.server) await session.server.close();
+    if (session.transport) await session.transport.close();
+  } catch (e) {
+    strapi.log.warn(`[${PLUGIN_ID$2}:mcp] Error closing session ${sessionId}`, {
+      error: e instanceof Error ? e.message : String(e)
+    });
+  }
+}
+async function closeAllSessions(strapi, sessions) {
+  const closePromises = [...sessions.entries()].map(
+    ([id, session]) => closeSession(strapi, id, session)
+  );
+  await Promise.all(closePromises);
+  sessions.clear();
+  strapi.log.info(`[${PLUGIN_ID$2}:mcp] All MCP sessions closed`);
+}
+const destroy = async ({ strapi }) => {
+  try {
+    const plugin = strapi.plugin(PLUGIN_ID$2);
+    if (plugin.aiProvider) {
+      plugin.aiProvider.destroy();
+      plugin.aiProvider = void 0;
+    }
+    if (plugin.mcpSessions) {
+      await closeAllSessions(strapi, plugin.mcpSessions);
+    }
+    plugin.createMcpServer = null;
+    plugin.mcpSessions = null;
+  } catch (error) {
+    strapi.log.error(`[${PLUGIN_ID$2}] Error during cleanup`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {
+    anthropicApiKey: "",
+    provider: "anthropic",
+    chatModel: "claude-sonnet-4-20250514",
+    baseURL: void 0,
+    systemPrompt: "",
+    mcp: {
+      sessionTimeoutMs: 4 * 60 * 60 * 1e3,
+      maxSessions: 100,
+      cleanupInterval: 100
+    },
+    guardrails: {
+      enabled: true,
+      maxInputLength: 1e4
+    }
+  },
+  validator(config2) {
+    if (typeof config2 !== "object" || config2 === null) {
+      throw new Error("Config must be an object");
+    }
+    const c = config2;
+    if (c.anthropicApiKey && typeof c.anthropicApiKey !== "string") {
+      throw new Error("anthropicApiKey must be a string");
+    }
+    if (c.chatModel && typeof c.chatModel !== "string") {
+      throw new Error("chatModel must be a string");
+    }
+  }
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "ai_sdk_conversations";
+const info$1 = {
+  singularName: "conversation",
+  pluralName: "conversations",
+  displayName: "AI Conversation"
+};
+const options$1 = {
+  draftAndPublish: false
+};
+const pluginOptions$1 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$1 = {
+  title: {
+    type: "string",
+    required: true,
+    "default": "New conversation"
+  },
+  messages: {
+    type: "json",
+    required: true
+  },
+  adminUserId: {
+    type: "integer",
+    required: true
+  }
+};
+const schema$1 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const conversation = { schema: schema$1 };
+const kind = "collectionType";
+const collectionName = "ai_sdk_memories";
+const info = {
+  singularName: "memory",
+  pluralName: "memories",
+  displayName: "AI Memory"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  content: {
+    type: "text",
+    required: true
+  },
+  category: {
+    type: "enumeration",
+    "enum": [
+      "general",
+      "preference",
+      "personal",
+      "project"
+    ],
+    "default": "general"
+  },
+  adminUserId: {
+    type: "integer",
+    required: true
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const memory = { schema };
+const contentTypes = { conversation, memory };
+function getService(strapi, ctx) {
+  const service2 = strapi.plugin("ai-sdk").service("service");
+  if (!service2.isInitialized()) {
+    ctx.badRequest("AI SDK not initialized. Check plugin configuration.");
+    return null;
+  }
+  return service2;
+}
+function validateBody(ctx) {
+  const { prompt, system } = ctx.request.body;
+  if (!prompt || typeof prompt !== "string") {
+    ctx.badRequest("prompt is required and must be a string");
+    return null;
+  }
+  if (system !== void 0 && typeof system !== "string") {
+    ctx.badRequest("system must be a string if provided");
+    return null;
+  }
+  return { prompt, system };
+}
+function validateChatBody(ctx) {
+  const { messages, system } = ctx.request.body;
+  if (!messages || !Array.isArray(messages) || messages.length === 0) {
+    ctx.badRequest("messages is required and must be a non-empty array");
+    return null;
+  }
+  if (system !== void 0 && typeof system !== "string") {
+    ctx.badRequest("system must be a string if provided");
+    return null;
+  }
+  return { messages, system };
+}
+function createSSEStream(ctx) {
+  ctx.set({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-transform",
+    "Connection": "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  const stream = new PassThrough();
+  ctx.body = stream;
+  ctx.res.flushHeaders();
+  return stream;
+}
+function writeSSE(stream, data) {
+  stream.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+const PLUGIN_ID$1 = "ai-sdk";
+const controller = ({ strapi }) => ({
+  async ask(ctx) {
+    const body = validateBody(ctx);
+    if (!body) return;
+    const service2 = getService(strapi, ctx);
+    if (!service2) return;
+    const result = await service2.ask(body.prompt, { system: body.system });
+    ctx.body = { data: { text: result } };
+  },
+  async askStream(ctx) {
+    const body = validateBody(ctx);
+    if (!body) return;
+    const service2 = getService(strapi, ctx);
+    if (!service2) return;
+    const textStream = await service2.askStream(body.prompt, { system: body.system });
+    const stream = createSSEStream(ctx);
+    (async () => {
+      try {
+        for await (const chunk of textStream) {
+          writeSSE(stream, { text: chunk });
+        }
+        stream.write("data: [DONE]\n\n");
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          strapi.log.debug("AI SDK stream aborted by client");
+        } else {
+          strapi.log.error("AI SDK stream error:", error);
+        }
+        const errorMessage = error instanceof Error ? error.message : "Stream error occurred";
+        writeSSE(stream, { error: errorMessage });
+      } finally {
+        stream.end();
+      }
+    })().catch((error) => {
+      strapi.log.error("Uncaught stream error:", error);
+      stream.end();
+    });
+  },
+  /**
+   * Chat endpoint using AI SDK UI message stream protocol
+   * Compatible with useChat hook from @ai-sdk/react
+   */
+  async chat(ctx) {
+    const body = validateChatBody(ctx);
+    if (!body) return;
+    const service2 = getService(strapi, ctx);
+    if (!service2) return;
+    const adminUserId = ctx.state?.user?.id;
+    const result = await service2.chat(body.messages, { system: body.system, adminUserId });
+    const response = result.toUIMessageStreamResponse();
+    ctx.status = 200;
+    ctx.set("Content-Type", "text/event-stream; charset=utf-8");
+    ctx.set("Cache-Control", "no-cache, no-transform");
+    ctx.set("Connection", "keep-alive");
+    ctx.set("X-Accel-Buffering", "no");
+    ctx.set("x-vercel-ai-ui-message-stream", "v1");
+    ctx.body = Readable.fromWeb(response.body);
+  },
+  async tts(ctx) {
+    const { text } = ctx.request.body;
+    if (!text || typeof text !== "string") {
+      ctx.status = 400;
+      ctx.body = { error: 'Missing "text" field' };
+      return;
+    }
+    const plugin = strapi.plugin(PLUGIN_ID$1);
+    if (!plugin.ttsProvider) {
+      ctx.status = 501;
+      ctx.body = { error: "TTS not configured" };
+      return;
+    }
+    try {
+      const buffer = await plugin.ttsProvider.synthesize(text);
+      ctx.status = 200;
+      ctx.set("Content-Type", "audio/wav");
+      ctx.body = buffer;
+    } catch (error) {
+      strapi.log.error("[ai-sdk] TTS error:", error);
+      ctx.status = 502;
+      ctx.body = { error: "TTS synthesis failed" };
+    }
+  }
+});
+const PLUGIN_ID = "ai-sdk";
+const DEFAULT_SESSION_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+const DEFAULT_MAX_SESSIONS = 100;
+const DEFAULT_CLEANUP_INTERVAL = 100;
+function isSessionExpired(session, timeoutMs) {
+  return Date.now() - session.createdAt > timeoutMs;
+}
+async function cleanupExpiredSessions(plugin, strapi, timeoutMs) {
+  let cleaned = 0;
+  for (const [sessionId, session] of plugin.mcpSessions.entries()) {
+    if (isSessionExpired(session, timeoutMs)) {
+      try {
+        await session.server.close();
+      } catch {
+      }
+      plugin.mcpSessions.delete(sessionId);
+      cleaned++;
+    }
+  }
+  if (cleaned > 0) {
+    strapi.log.debug(`[${PLUGIN_ID}:mcp] Cleaned up ${cleaned} expired sessions`);
+  }
+}
+async function closeSessionQuietly(server) {
+  try {
+    await server.close();
+  } catch {
+  }
+}
+function jsonRpcError(ctx, status, code, message) {
+  ctx.status = status;
+  ctx.body = { jsonrpc: "2.0", error: { code, message }, id: null };
+}
+function getSessionId(ctx) {
+  const raw = ctx.request.headers["mcp-session-id"];
+  return Array.isArray(raw) ? raw[0] : raw;
+}
+async function resolveSession(plugin, strapi, requestedSessionId, timeoutMs) {
+  if (!requestedSessionId) return { session: null, expired: false };
+  const session = plugin.mcpSessions.get(requestedSessionId) ?? null;
+  if (!session) return { session: null, expired: false };
+  if (isSessionExpired(session, timeoutMs)) {
+    strapi.log.debug(`[${PLUGIN_ID}:mcp] Session expired, removing: ${requestedSessionId}`);
+    await closeSessionQuietly(session.server);
+    plugin.mcpSessions.delete(requestedSessionId);
+    return { session: null, expired: true };
+  }
+  return { session, expired: false };
+}
+async function createSession(plugin, strapi, maxSessions, timeoutMs) {
+  if (plugin.mcpSessions.size >= maxSessions) {
+    await cleanupExpiredSessions(plugin, strapi, timeoutMs);
+    if (plugin.mcpSessions.size >= maxSessions) return null;
+  }
+  const sessionId = randomUUID();
+  if (!plugin.createMcpServer) return null;
+  const server = plugin.createMcpServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => sessionId
+  });
+  await server.connect(transport);
+  const session = { server, transport, createdAt: Date.now() };
+  plugin.mcpSessions.set(sessionId, session);
+  strapi.log.debug(`[${PLUGIN_ID}:mcp] New session created: ${sessionId}`);
+  return { session, sessionId };
+}
+async function handleTransport(ctx, session, currentSessionId, plugin, strapi) {
+  try {
+    await session.transport.handleRequest(ctx.req, ctx.res, ctx.request.body);
+    ctx.respond = false;
+  } catch (transportError) {
+    strapi.log.warn(`[${PLUGIN_ID}:mcp] Transport error, cleaning up session: ${currentSessionId}`, {
+      error: transportError instanceof Error ? transportError.message : String(transportError)
+    });
+    await closeSessionQuietly(session.server);
+    if (currentSessionId) {
+      plugin.mcpSessions.delete(currentSessionId);
+    }
+    if (!ctx.res.headersSent) {
+      jsonRpcError(ctx, 400, -32e3, "Session transport error. Please reinitialize the connection.");
+    }
+  }
+}
+async function getOrCreateSession(plugin, strapi, requestedSessionId, maxSessions, timeoutMs) {
+  const { session: existing, expired } = await resolveSession(plugin, strapi, requestedSessionId, timeoutMs);
+  if (requestedSessionId && !existing) {
+    return {
+      ok: false,
+      status: 400,
+      code: -32e3,
+      message: expired ? "Session expired. Please reinitialize the connection." : "Session not found. Please reinitialize the connection."
+    };
+  }
+  if (existing) {
+    return { ok: true, session: existing, sessionId: requestedSessionId };
+  }
+  const created = await createSession(plugin, strapi, maxSessions, timeoutMs);
+  if (!created) {
+    return { ok: false, status: 429, code: -32e3, message: "Too many active sessions. Please try again later." };
+  }
+  return { ok: true, session: created.session, sessionId: created.sessionId };
+}
+function isInvalidPostBody(ctx) {
+  return ctx.method === "POST" && (typeof ctx.request.body !== "object" || ctx.request.body === null);
+}
+const mcpController = ({ strapi }) => {
+  const config2 = strapi.config.get("plugin::ai-sdk");
+  const timeoutMs = config2?.mcp?.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
+  const maxSessions = config2?.mcp?.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  const cleanupInterval = config2?.mcp?.cleanupInterval ?? DEFAULT_CLEANUP_INTERVAL;
+  let requestCount = 0;
+  return {
+    async handle(ctx) {
+      const plugin = strapi.plugin(PLUGIN_ID);
+      if (!plugin.createMcpServer) {
+        ctx.status = 503;
+        ctx.body = { error: "MCP not initialized", message: "The MCP server is not available. Check plugin configuration." };
+        return;
+      }
+      if (++requestCount % cleanupInterval === 0) {
+        await cleanupExpiredSessions(plugin, strapi, timeoutMs);
+      }
+      try {
+        const result = await getOrCreateSession(plugin, strapi, getSessionId(ctx), maxSessions, timeoutMs);
+        if (result.ok === false) {
+          jsonRpcError(ctx, result.status, result.code, result.message);
+          return;
+        }
+        if (isInvalidPostBody(ctx)) {
+          jsonRpcError(ctx, 400, -32700, "Invalid JSON-RPC request");
+          return;
+        }
+        await handleTransport(ctx, result.session, result.sessionId, plugin, strapi);
+      } catch (error) {
+        strapi.log.error(`[${PLUGIN_ID}:mcp] Error handling MCP request`, {
+          error: error instanceof Error ? error.message : String(error),
+          method: ctx.method,
+          path: ctx.path
+        });
+        if (!ctx.res.headersSent) {
+          ctx.status = 500;
+          ctx.body = { error: "MCP request failed", message: error instanceof Error ? error.message : "Unknown error" };
+        }
+      }
+    }
+  };
+};
+const CONTENT_TYPE$1 = "plugin::ai-sdk.conversation";
+function getAdminUserId$1(ctx) {
+  const id = ctx.state?.user?.id;
+  return typeof id === "number" ? id : null;
+}
+const conversationController = ({ strapi }) => ({
+  async find(ctx) {
+    const adminUserId = getAdminUserId$1(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const conversations = await strapi.documents(CONTENT_TYPE$1).findMany({
+      filters: { adminUserId },
+      fields: ["title", "createdAt", "updatedAt"],
+      sort: { updatedAt: "desc" }
+    });
+    ctx.body = { data: conversations };
+  },
+  async findOne(ctx) {
+    const adminUserId = getAdminUserId$1(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { id } = ctx.params;
+    const conversation2 = await strapi.documents(CONTENT_TYPE$1).findOne({
+      documentId: id
+    });
+    if (!conversation2 || conversation2.adminUserId !== adminUserId) {
+      ctx.status = 404;
+      ctx.body = { error: "Conversation not found" };
+      return;
+    }
+    ctx.body = { data: conversation2 };
+  },
+  async create(ctx) {
+    const adminUserId = getAdminUserId$1(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { title, messages } = ctx.request.body;
+    const conversation2 = await strapi.documents(CONTENT_TYPE$1).create({
+      data: {
+        title: title || "New conversation",
+        messages: messages || [],
+        adminUserId
+      }
+    });
+    ctx.status = 201;
+    ctx.body = { data: conversation2 };
+  },
+  async update(ctx) {
+    const adminUserId = getAdminUserId$1(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { id } = ctx.params;
+    const existing = await strapi.documents(CONTENT_TYPE$1).findOne({
+      documentId: id
+    });
+    if (!existing || existing.adminUserId !== adminUserId) {
+      ctx.status = 404;
+      ctx.body = { error: "Conversation not found" };
+      return;
+    }
+    const { title, messages } = ctx.request.body;
+    const data = {};
+    if (title !== void 0) data.title = title;
+    if (messages !== void 0) data.messages = messages;
+    const conversation2 = await strapi.documents(CONTENT_TYPE$1).update({
+      documentId: id,
+      data
+    });
+    ctx.body = { data: conversation2 };
+  },
+  async delete(ctx) {
+    const adminUserId = getAdminUserId$1(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { id } = ctx.params;
+    const existing = await strapi.documents(CONTENT_TYPE$1).findOne({
+      documentId: id
+    });
+    if (!existing || existing.adminUserId !== adminUserId) {
+      ctx.status = 404;
+      ctx.body = { error: "Conversation not found" };
+      return;
+    }
+    await strapi.documents(CONTENT_TYPE$1).delete({ documentId: id });
+    ctx.status = 200;
+    ctx.body = { data: { documentId: id } };
+  }
+});
+const CONTENT_TYPE = "plugin::ai-sdk.memory";
+function getAdminUserId(ctx) {
+  const id = ctx.state?.user?.id;
+  return typeof id === "number" ? id : null;
+}
+const memoryController = ({ strapi }) => ({
+  async find(ctx) {
+    const adminUserId = getAdminUserId(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const memories = await strapi.documents(CONTENT_TYPE).findMany({
+      filters: { adminUserId },
+      fields: ["content", "category", "createdAt"],
+      sort: { createdAt: "desc" }
+    });
+    ctx.body = { data: memories };
+  },
+  async create(ctx) {
+    const adminUserId = getAdminUserId(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { content, category } = ctx.request.body;
+    if (!content || typeof content !== "string") {
+      ctx.status = 400;
+      ctx.body = { error: "content is required" };
+      return;
+    }
+    const memory2 = await strapi.documents(CONTENT_TYPE).create({
+      data: {
+        content,
+        category: category || "general",
+        adminUserId
+      }
+    });
+    ctx.status = 201;
+    ctx.body = { data: memory2 };
+  },
+  async update(ctx) {
+    const adminUserId = getAdminUserId(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { id } = ctx.params;
+    const existing = await strapi.documents(CONTENT_TYPE).findOne({
+      documentId: id
+    });
+    if (!existing || existing.adminUserId !== adminUserId) {
+      ctx.status = 404;
+      ctx.body = { error: "Memory not found" };
+      return;
+    }
+    const { content, category } = ctx.request.body;
+    const data = {};
+    if (content !== void 0) data.content = content;
+    if (category !== void 0) data.category = category;
+    const memory2 = await strapi.documents(CONTENT_TYPE).update({
+      documentId: id,
+      data
+    });
+    ctx.body = { data: memory2 };
+  },
+  async delete(ctx) {
+    const adminUserId = getAdminUserId(ctx);
+    if (!adminUserId) {
+      ctx.status = 401;
+      ctx.body = { error: "Unauthorized" };
+      return;
+    }
+    const { id } = ctx.params;
+    const existing = await strapi.documents(CONTENT_TYPE).findOne({
+      documentId: id
+    });
+    if (!existing || existing.adminUserId !== adminUserId) {
+      ctx.status = 404;
+      ctx.body = { error: "Memory not found" };
+      return;
+    }
+    await strapi.documents(CONTENT_TYPE).delete({ documentId: id });
+    ctx.status = 200;
+    ctx.body = { data: { documentId: id } };
+  }
+});
+const controllers = {
+  controller,
+  mcp: mcpController,
+  conversation: conversationController,
+  memory: memoryController
+};
+const promptInjection = [
+  "ignore (all |any )?(previous|prior|above) (instructions|prompts|rules)",
+  "disregard (your|all|any) (instructions|rules|guidelines)",
+  "new instructions\\s*:",
+  "forget (your|all|everything|previous|what you were told)",
+  "override (your|the|all) (instructions|system|rules|safety)",
+  "bypass (your|all|the) (rules|restrictions|filters|safety|guidelines)"
+];
+const jailbreak = [
+  "you are now (in )?(developer|admin|unrestricted|god) mode",
+  "pretend you (are|have no|don't have)",
+  "act as if you (have no|are not|don't have)",
+  "do anything now",
+  "\\bDAN\\b.*mode",
+  "jailbreak",
+  "unrestricted mode",
+  "no (restrictions|limitations|rules|filters|safety)"
+];
+const systemPromptExtraction = [
+  "(reveal|show|print|output|display|repeat) (me )?(your )?(system )?(prompt|instructions|rules|guidelines)",
+  "what (is|are) your (system )?(prompt|instructions|rules)",
+  "what were you told",
+  "repeat the (above|system|initial) (text|prompt|instructions|message)"
+];
+const systemPromptMimicry = [
+  "^\\s*\\[?(system|SYSTEM)\\]?\\s*:",
+  "^\\s*<\\|?(system|SYSTEM)\\|?>",
+  "<<\\s*SYS\\s*>>",
+  "SYSTEM_INSTRUCTIONS"
+];
+const destructive = [
+  "rm\\s+-rf",
+  "drop\\s+(table|database|all)",
+  "delete\\s+(all|every|each)\\s+(content|entries|documents|records|data)",
+  "truncate\\s+table",
+  "remove\\s+(all|every|each)\\s+(content|entries|documents|records)",
+  "wipe\\s+(all\\s+the\\s+|all\\s+|the\\s+)(data|content|database)",
+  "destroy\\s+(all|every|each)\\s+(content|entries|documents|records)"
+];
+const defaultPatterns = {
+  promptInjection,
+  jailbreak,
+  systemPromptExtraction,
+  systemPromptMimicry,
+  destructive
+};
+const DEFAULT_MAX_INPUT_LENGTH = 1e4;
+const DEFAULT_BLOCKED_MESSAGE$1 = "I'm unable to process that request. It was flagged by content safety guardrails.";
+const INVISIBLE_CHARS = /[\u200B-\u200F\u2028-\u202F\u2060-\u2064\uFEFF\u00AD]/g;
+function normalizeInput(text) {
+  return text.normalize("NFKC").replace(INVISIBLE_CHARS, "").replace(/\s+/g, " ").trim();
+}
+function loadPatterns(config2) {
+  const sources = [];
+  if (!config2?.disableDefaultPatterns) {
+    for (const category of Object.values(defaultPatterns)) {
+      sources.push(...category);
+    }
+  }
+  if (config2?.additionalPatterns) {
+    sources.push(...config2.additionalPatterns);
+  }
+  return sources.map((p) => new RegExp(p, "i"));
+}
+function extractUserInput(ctx) {
+  const path = ctx.path;
+  const method = ctx.method;
+  const body = ctx.request.body;
+  if (path.endsWith("/mcp") && (method === "GET" || method === "DELETE")) {
+    return null;
+  }
+  if (path.endsWith("/mcp") && method === "POST") {
+    if (body && typeof body === "object" && "params" in body) {
+      return { text: JSON.stringify(body.params), route: "mcp" };
+    }
+    return null;
+  }
+  if (path.endsWith("/chat") && method === "POST") {
+    if (body && Array.isArray(body.messages)) {
+      const messages = body.messages;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "user") continue;
+        if (Array.isArray(msg.parts)) {
+          const textParts = msg.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text);
+          if (textParts.length > 0) {
+            return { text: textParts.join(" "), route: "chat" };
+          }
+        }
+        if (typeof msg.content === "string") {
+          return { text: msg.content, route: "chat" };
+        }
+      }
+    }
+    return null;
+  }
+  if ((path.endsWith("/ask") || path.endsWith("/ask-stream")) && method === "POST") {
+    if (body && typeof body.prompt === "string") {
+      return { text: body.prompt, route: path.endsWith("/ask-stream") ? "ask-stream" : "ask" };
+    }
+    return null;
+  }
+  return null;
+}
+function checkPatterns(text, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.test(text)) {
+      return pattern.source;
+    }
+  }
+  return null;
+}
+async function runGuardrails(text, route, ctx, config2, patterns) {
+  const blockedMessage = config2?.blockedMessage ?? DEFAULT_BLOCKED_MESSAGE$1;
+  if (config2?.beforeProcess) {
+    const hookResult = await config2.beforeProcess({ text, route, ctx });
+    if (hookResult.blocked) {
+      return { blocked: true, reason: hookResult.reason ?? blockedMessage };
+    }
+    if (hookResult.sanitized) {
+      text = hookResult.sanitized;
+    }
+  }
+  const normalized = normalizeInput(text);
+  const matchedPattern = checkPatterns(normalized, patterns);
+  if (matchedPattern) {
+    return { blocked: true, reason: blockedMessage };
+  }
+  const maxLength = config2?.maxInputLength ?? DEFAULT_MAX_INPUT_LENGTH;
+  if (text.length > maxLength) {
+    return {
+      blocked: true,
+      reason: `Input exceeds maximum allowed length of ${maxLength} characters.`
+    };
+  }
+  return { blocked: false };
+}
+const DEFAULT_BLOCKED_MESSAGE = "I'm unable to process that request. It was flagged by content safety guardrails.";
+function respondWithChatMessage(ctx, message) {
+  ctx.status = 200;
+  ctx.set("Content-Type", "text/event-stream; charset=utf-8");
+  ctx.set("Cache-Control", "no-cache, no-transform");
+  ctx.set("Connection", "keep-alive");
+  ctx.set("X-Accel-Buffering", "no");
+  const stream = new PassThrough();
+  ctx.body = stream;
+  ctx.res.flushHeaders();
+  stream.write(`data: ${JSON.stringify({ type: "text-delta", delta: message })}
+
+`);
+  stream.write("data: [DONE]\n\n");
+  stream.end();
+}
+const guardrail = (_config, { strapi }) => {
+  const pluginConfig = strapi.config.get("plugin::ai-sdk");
+  const guardrailConfig = pluginConfig?.guardrails;
+  const patterns = loadPatterns(guardrailConfig);
+  return async (ctx, next) => {
+    if (guardrailConfig?.enabled === false) return next();
+    const extracted = extractUserInput(ctx);
+    if (!extracted) return next();
+    const { text, route } = extracted;
+    const result = await runGuardrails(text, route, ctx, guardrailConfig, patterns);
+    if (!result.blocked) return next();
+    const reason = result.reason ?? guardrailConfig?.blockedMessage ?? DEFAULT_BLOCKED_MESSAGE;
+    if (route === "chat") {
+      respondWithChatMessage(ctx, reason);
+    } else {
+      ctx.status = 403;
+      ctx.body = { error: "Request blocked by guardrails", reason };
+    }
+  };
+};
+const middlewares = { guardrail };
+const policies = {};
+const contentAPIRoutes = {
+  type: "content-api",
+  routes: [
+    {
+      method: "POST",
+      path: "/ask",
+      handler: "controller.ask",
+      config: {
+        policies: [],
+        middlewares: ["plugin::ai-sdk.guardrail"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/ask-stream",
+      handler: "controller.askStream",
+      config: {
+        policies: [],
+        middlewares: ["plugin::ai-sdk.guardrail"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/chat",
+      handler: "controller.chat",
+      config: {
+        policies: [],
+        middlewares: ["plugin::ai-sdk.guardrail"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/mcp",
+      handler: "mcp.handle",
+      config: {
+        policies: [],
+        middlewares: ["plugin::ai-sdk.guardrail"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/mcp",
+      handler: "mcp.handle",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/mcp",
+      handler: "mcp.handle",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const adminAPIRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "POST",
+      path: "/chat",
+      handler: "controller.chat",
+      config: {
+        policies: [],
+        middlewares: ["plugin::ai-sdk.guardrail"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/tts",
+      handler: "controller.tts",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/conversations",
+      handler: "conversation.find",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/conversations/:id",
+      handler: "conversation.findOne",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/conversations",
+      handler: "conversation.create",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/conversations/:id",
+      handler: "conversation.update",
+      config: { policies: [] }
+    },
+    {
+      method: "DELETE",
+      path: "/conversations/:id",
+      handler: "conversation.delete",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/memories",
+      handler: "memory.find",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/memories",
+      handler: "memory.create",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/memories/:id",
+      handler: "memory.update",
+      config: { policies: [] }
+    },
+    {
+      method: "DELETE",
+      path: "/memories/:id",
+      handler: "memory.delete",
+      config: { policies: [] }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+function createTools(strapi, context) {
+  const plugin = strapi.plugin("ai-sdk");
+  const registry = plugin.toolRegistry;
+  if (!registry) {
+    throw new Error("Tool registry not initialized");
+  }
+  const tools = {};
+  for (const [name, def] of registry.getAll()) {
+    tools[name] = tool({
+      description: def.description,
+      inputSchema: zodSchema(def.schema),
+      execute: async (args) => def.execute(args, strapi, context)
+    });
+  }
+  return tools;
+}
+function describeTools(tools) {
+  const lines = Object.entries(tools).map(
+    ([name, t]) => `- ${name}: ${t.description ?? "No description"}`
+  );
+  return `Available tools:
+${lines.join("\n")}`;
+}
+const DEFAULT_PREAMBLE = "You are a Strapi CMS assistant. Use your tools to fulfill user requests. When asked to create or update content, use the appropriate tool — do not tell the user you cannot.";
+function composeSystemPrompt(config2, toolsDescription, override) {
+  const base = override || config2?.systemPrompt || DEFAULT_PREAMBLE;
+  if (base.includes("{tools}")) {
+    return base.replace("{tools}", toolsDescription);
+  }
+  return `${base}
+
+${toolsDescription}`;
+}
+const service = ({ strapi }) => {
+  const plugin = strapi.plugin("ai-sdk");
+  return {
+    async ask(prompt, options2) {
+      const result = await plugin.aiProvider.generateText(prompt, {
+        system: options2?.system
+      });
+      return result.text;
+    },
+    async askStream(prompt, options2) {
+      const result = await plugin.aiProvider.streamText(prompt, {
+        system: options2?.system
+      });
+      return result.textStream;
+    },
+    /**
+     * Chat with messages - returns raw stream for UI message stream response
+     * Compatible with AI SDK UI hooks (useChat)
+     */
+    async chat(messages, options2) {
+      const config2 = strapi.config.get("plugin::ai-sdk");
+      const modelMessages = await convertToModelMessages(messages);
+      const tools = createTools(strapi, { adminUserId: options2?.adminUserId });
+      const toolsDescription = describeTools(tools);
+      let system = composeSystemPrompt(config2, toolsDescription, options2?.system);
+      if (options2?.adminUserId) {
+        try {
+          const memories = await strapi.documents("plugin::ai-sdk.memory").findMany({
+            filters: { adminUserId: options2.adminUserId },
+            fields: ["content", "category"]
+          });
+          if (memories.length > 0) {
+            const lines = memories.map((m) => `- [${m.category}] ${m.content}`);
+            system += `
+
+User memories (facts you have saved about this user from previous conversations — use these to personalize your responses):
+${lines.join("\n")}`;
+          }
+        } catch (err) {
+          strapi.log.warn("[ai-sdk] Failed to load user memories:", err);
+        }
+      }
+      return plugin.aiProvider.streamRaw({
+        messages: modelMessages,
+        system,
+        tools,
+        stopWhen: stepCountIs(6)
+      });
+    },
+    isInitialized() {
+      return plugin.aiProvider?.isInitialized() ?? false;
+    }
+  };
+};
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};