yt-transcript-strapi-plugin 0.1.5 → 0.2.0

package/dist/server/index.js

@@ -37,26 +37,6 @@ const FindTranscriptsSchema = zod.z.object({
   pageSize: zod.z.number().int().min(1).max(100).optional().default(25),
   sort: zod.z.string().optional().default("createdAt:desc")
 });
-const ToolSchemas = {
-  fetch_transcript: FetchTranscriptSchema,
-  list_transcripts: ListTranscriptsSchema,
-  get_transcript: GetTranscriptSchema,
-  search_transcript: SearchTranscriptSchema,
-  find_transcripts: FindTranscriptsSchema
-};
-function validateToolInput(toolName, input) {
-  const schema2 = ToolSchemas[toolName];
-  const result = schema2.safeParse(input);
-  if (!result.success) {
-    const errorMessages = result.error.issues.map((err) => {
-      const path = err.path.length > 0 ? `${err.path.join(".")}: ` : "";
-      return `${path}${err.message}`;
-    });
-    throw new Error(`Validation failed for ${toolName}:
-${errorMessages.join("\n")}`);
-  }
-  return result.data;
-}
 function extractYouTubeID(urlOrID) {
   const regExpID = /^[a-zA-Z0-9_-]{11}$/;
   if (regExpID.test(urlOrID)) {
@@ -74,20 +54,6 @@ function extractYouTubeID(urlOrID) {
   }
   return null;
 }
-const fetchTranscriptTool = {
-  name: "fetch_transcript",
-  description: "Fetch a transcript from YouTube for a given video ID or URL. The transcript is saved to the database. Returns metadata and preview only to avoid context overflow. Use get_transcript to retrieve content.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      videoId: {
-        type: "string",
-        description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
-      }
-    },
-    required: ["videoId"]
-  }
-};
 function getVideoDurationMs$1(timecodes) {
   if (!timecodes || timecodes.length === 0) return 0;
   const lastEntry = timecodes[timecodes.length - 1];
@@ -121,11 +87,11 @@ function buildMetadataResponse(transcript2, previewLength, cached) {
       durationSeconds: Math.floor(durationMs / 1e3)
     },
     preview,
-    usage: "Use get_transcript with videoId to retrieve full content, specific time ranges, or paginated chunks."
+    usage: "Use getTranscript with videoId to retrieve full content, specific time ranges, or paginated chunks."
   };
 }
-async function handleFetchTranscript(strapi, args) {
-  const validatedArgs = validateToolInput("fetch_transcript", args);
+async function execute$4(args, strapi) {
+  const validatedArgs = FetchTranscriptSchema.parse(args);
   const { videoId: videoIdOrUrl } = validatedArgs;
   const pluginConfig = await strapi.config.get("plugin::yt-transcript-strapi-plugin");
   const previewLength = pluginConfig?.previewLength || 500;
@@ -136,18 +102,7 @@ async function handleFetchTranscript(strapi, args) {
   const service2 = strapi.plugin("yt-transcript-strapi-plugin").service("service");
   const existingTranscript = await service2.findTranscript(videoId);
   if (existingTranscript) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            buildMetadataResponse(existingTranscript, previewLength, true),
-            null,
-            2
-          )
-        }
-      ]
-    };
+    return buildMetadataResponse(existingTranscript, previewLength, true);
   }
   const transcriptData = await service2.getTranscript(videoId);
   if (!transcriptData || !transcriptData.fullTranscript) {
@@ -160,46 +115,17 @@ async function handleFetchTranscript(strapi, args) {
     transcriptWithTimeCodes: transcriptData.transcriptWithTimeCodes
   };
   const savedTranscript = await service2.saveTranscript(payload);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          buildMetadataResponse(savedTranscript, previewLength, false),
-          null,
-          2
-        )
-      }
-    ]
-  };
+  return buildMetadataResponse(savedTranscript, previewLength, false);
 }
-const listTranscriptsTool = {
-  name: "list_transcripts",
-  description: "List all saved YouTube transcripts from the database. Supports pagination and sorting.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      page: {
-        type: "number",
-        description: "Page number (starts at 1)",
-        default: 1
-      },
-      pageSize: {
-        type: "number",
-        description: "Number of items per page (max 100)",
-        default: 25
-      },
-      sort: {
-        type: "string",
-        description: 'Sort order (e.g., "createdAt:desc", "title:asc")',
-        default: "createdAt:desc"
-      }
-    },
-    required: []
-  }
+const fetchTranscriptTool = {
+  name: "fetchTranscript",
+  description: "Fetch a transcript from YouTube for a given video ID or URL. The transcript is saved to the database. Returns metadata and preview only to avoid context overflow. Use getTranscript to retrieve content.",
+  schema: FetchTranscriptSchema,
+  execute: execute$4,
+  publicSafe: true
 };
-async function handleListTranscripts(strapi, args) {
-  const validatedArgs = validateToolInput("list_transcripts", args);
+async function execute$3(args, strapi) {
+  const validatedArgs = ListTranscriptsSchema.parse(args);
   const { page, pageSize, sort } = validatedArgs;
   const start = (page - 1) * pageSize;
   const transcripts = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
@@ -211,65 +137,21 @@ async function handleListTranscripts(strapi, args) {
   const allTranscripts = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({});
   const total = allTranscripts.length;
   return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            data: transcripts,
-            pagination: {
-              page,
-              pageSize,
-              total,
-              pageCount: Math.ceil(total / pageSize)
-            }
-          },
-          null,
-          2
-        )
-      }
-    ]
+    data: transcripts,
+    pagination: {
+      page,
+      pageSize,
+      total,
+      pageCount: Math.ceil(total / pageSize)
+    }
   };
 }
-const getTranscriptTool = {
-  name: "get_transcript",
-  description: "Get a saved transcript by YouTube video ID. Returns metadata and preview by default. Use parameters to get full content or specific time ranges to avoid context overflow.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      videoId: {
-        type: "string",
-        description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
-      },
-      includeFullTranscript: {
-        type: "boolean",
-        description: "Include the complete transcript text. Warning: may cause context overflow for long videos. Default: false",
-        default: false
-      },
-      includeTimecodes: {
-        type: "boolean",
-        description: "Include the transcript with timecodes array. Warning: significantly increases response size. Default: false",
-        default: false
-      },
-      startTime: {
-        type: "number",
-        description: "Start time in seconds for fetching a specific portion of the transcript"
-      },
-      endTime: {
-        type: "number",
-        description: "End time in seconds for fetching a specific portion of the transcript"
-      },
-      chunkIndex: {
-        type: "number",
-        description: "Chunk index (0-based) when paginating through transcript. Use with chunkSize to paginate through long videos."
-      },
-      chunkSize: {
-        type: "number",
-        description: "Chunk size in seconds. Overrides config default. Use with chunkIndex for pagination."
-      }
-    },
-    required: ["videoId"]
-  }
+const listTranscriptsTool = {
+  name: "listTranscripts",
+  description: "List all saved YouTube transcripts from the database. Supports pagination and sorting.",
+  schema: ListTranscriptsSchema,
+  execute: execute$3,
+  publicSafe: true
 };
 function getTranscriptForTimeRange(timecodes, startTimeMs, endTimeMs) {
   const entries = timecodes.filter(
@@ -293,8 +175,8 @@ function formatTime$1(ms) {
   }
   return `${minutes}:${seconds.toString().padStart(2, "0")}`;
 }
-async function handleGetTranscript(strapi, args) {
-  const validatedArgs = validateToolInput("get_transcript", args);
+async function execute$2(args, strapi) {
+  const validatedArgs = GetTranscriptSchema.parse(args);
   const {
     videoId: videoIdOrUrl,
     includeFullTranscript,
@@ -317,20 +199,9 @@ async function handleGetTranscript(strapi, args) {
   const transcript2 = await service2.findTranscript(videoId);
   if (!transcript2) {
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              error: true,
-              message: `No transcript found for video ID: ${videoId}. Use fetch_transcript to fetch it from YouTube first.`,
-              videoId
-            },
-            null,
-            2
-          )
-        }
-      ]
+      error: true,
+      message: `No transcript found for video ID: ${videoId}. Use fetchTranscript to fetch it from YouTube first.`,
+      videoId
     };
   }
   const timecodes = transcript2.transcriptWithTimeCodes || [];
@@ -396,7 +267,7 @@ async function handleGetTranscript(strapi, args) {
       response.transcriptWithTimeCodes = timecodes;
     }
     if (includeFullTranscript && fullText.length > maxFullTranscriptLength) {
-      response.warning = "Full transcript included. For long videos, consider using chunkIndex, startTime/endTime, or search_transcript to reduce response size.";
+      response.warning = "Full transcript included. For long videos, consider using chunkIndex, startTime/endTime, or searchTranscript to reduce response size.";
     } else if (fullText.length <= maxFullTranscriptLength) {
       response.note = "Full transcript auto-loaded (fits within context limit).";
     }
@@ -406,42 +277,19 @@ async function handleGetTranscript(strapi, args) {
     response.isLargeTranscript = true;
     response.usage = {
       fullTranscript: "Set includeFullTranscript: true to get complete text (warning: may exceed context)",
-      search: "Use search_transcript to find relevant portions by keyword (recommended for large transcripts)",
+      search: "Use searchTranscript to find relevant portions by keyword (recommended for large transcripts)",
       timeRange: "Use startTime and endTime (in seconds) to get a specific portion",
       pagination: `Use chunkIndex (0-${totalChunks - 1}) to paginate through ${chunkSizeSeconds}s chunks`
     };
   }
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(response, null, 2)
-      }
-    ]
-  };
+  return response;
 }
-const searchTranscriptTool = {
-  name: "search_transcript",
-  description: "Search within a saved transcript using BM25 scoring. Returns the most relevant segments matching your query with timestamps. Use this to find specific content in long videos without loading the entire transcript.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      videoId: {
-        type: "string",
-        description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
-      },
-      query: {
-        type: "string",
-        description: "Search query - keywords or phrases to find in the transcript"
-      },
-      maxResults: {
-        type: "number",
-        description: "Maximum number of results to return (default: 5, max: 20)",
-        default: 5
-      }
-    },
-    required: ["videoId", "query"]
-  }
+const getTranscriptTool = {
+  name: "getTranscript",
+  description: "Get a saved transcript by YouTube video ID. Returns metadata and preview by default. Use parameters to get full content or specific time ranges to avoid context overflow.",
+  schema: GetTranscriptSchema,
+  execute: execute$2,
+  publicSafe: true
 };
 function tokenize(text) {
   return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 1);
@@ -521,8 +369,8 @@ function createSegments(timecodes, segmentDurationMs) {
   }
   return segments;
 }
-async function handleSearchTranscript(strapi, args) {
-  const validatedArgs = validateToolInput("search_transcript", args);
+async function execute$1(args, strapi) {
+  const validatedArgs = SearchTranscriptSchema.parse(args);
   const { videoId: videoIdOrUrl, query, maxResults: maxResultsInput } = validatedArgs;
   const pluginConfig = await strapi.config.get("plugin::yt-transcript-strapi-plugin");
   const segmentSeconds = pluginConfig?.searchSegmentSeconds || 30;
@@ -535,77 +383,33 @@ async function handleSearchTranscript(strapi, args) {
   const transcript2 = await service2.findTranscript(videoId);
   if (!transcript2) {
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              error: true,
-              message: `No transcript found for video ID: ${videoId}. Use fetch_transcript to fetch it from YouTube first.`,
-              videoId
-            },
-            null,
-            2
-          )
-        }
-      ]
+      error: true,
+      message: `No transcript found for video ID: ${videoId}. Use fetchTranscript to fetch it from YouTube first.`,
+      videoId
     };
   }
   const timecodes = transcript2.transcriptWithTimeCodes || [];
   if (timecodes.length === 0) {
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              error: true,
-              message: "Transcript has no timecode data for searching.",
-              videoId
-            },
-            null,
-            2
-          )
-        }
-      ]
+      error: true,
+      message: "Transcript has no timecode data for searching.",
+      videoId
     };
   }
   const segments = createSegments(timecodes, segmentSeconds * 1e3);
   if (segments.length === 0) {
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              error: true,
-              message: "Could not create searchable segments from transcript.",
-              videoId
-            },
-            null,
-            2
-          )
-        }
-      ]
+      error: true,
+      message: "Could not create searchable segments from transcript.",
+      videoId
     };
   }
   const queryTokens = tokenize(query);
   if (queryTokens.length === 0) {
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              error: true,
-              message: "Query is empty or contains only stop words.",
-              query
-            },
-            null,
-            2
-          )
-        }
-      ]
+      error: true,
+      message: "Query is empty or contains only stop words.",
+      query
     };
   }
   const vocabulary = new Set(queryTokens);
@@ -617,74 +421,29 @@ async function handleSearchTranscript(strapi, args) {
   }));
   const results = scoredSegments.filter((seg) => seg.score > 0).sort((a, b) => b.score - a.score).slice(0, maxResults);
   return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            videoId: transcript2.videoId,
-            title: transcript2.title,
-            query,
-            totalSegments: segments.length,
-            matchingResults: results.length,
-            results: results.map((r) => ({
-              text: r.text,
-              startTime: r.startTime,
-              endTime: r.endTime,
-              timeRange: `${r.startFormatted} - ${r.endFormatted}`,
-              score: Math.round(r.score * 100) / 100
-            })),
-            usage: results.length > 0 ? `Use get_transcript with startTime: ${results[0].startTime} and endTime: ${results[0].endTime} to get full context for the top result.` : "No matches found. Try different keywords."
-          },
-          null,
-          2
-        )
-      }
-    ]
+    videoId: transcript2.videoId,
+    title: transcript2.title,
+    query,
+    totalSegments: segments.length,
+    matchingResults: results.length,
+    results: results.map((r) => ({
+      text: r.text,
+      startTime: r.startTime,
+      endTime: r.endTime,
+      timeRange: `${r.startFormatted} - ${r.endFormatted}`,
+      score: Math.round(r.score * 100) / 100
+    })),
+    usage: results.length > 0 ? `Use getTranscript with startTime: ${results[0].startTime} and endTime: ${results[0].endTime} to get full context for the top result.` : "No matches found. Try different keywords."
   };
 }
-const TRANSCRIPT_PREVIEW_LENGTH = 244;
-const findTranscriptsTool = {
-  name: "find_transcripts",
-  description: "Search and filter transcripts based on query criteria. Returns multiple matching transcripts with truncated previews (244 chars). Use get_transcript for full content. Supports filtering by title, videoId, and full-text search.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: "Search query to match against title or transcript content"
-      },
-      videoId: {
-        type: "string",
-        description: "Filter by specific video ID (partial match supported)"
-      },
-      title: {
-        type: "string",
-        description: "Filter by title (partial match, case-insensitive)"
-      },
-      includeFullContent: {
-        type: "boolean",
-        description: "Set to true to include full transcript content. Default: false. Warning: may cause context overflow with multiple results."
-      },
-      page: {
-        type: "number",
-        description: "Page number (starts at 1)",
-        default: 1
-      },
-      pageSize: {
-        type: "number",
-        description: "Number of items per page (max 100)",
-        default: 25
-      },
-      sort: {
-        type: "string",
-        description: 'Sort order (e.g., "createdAt:desc", "title:asc")',
-        default: "createdAt:desc"
-      }
-    },
-    required: []
-  }
+const searchTranscriptTool = {
+  name: "searchTranscript",
+  description: "Search within a saved transcript using BM25 scoring. Returns the most relevant segments matching your query with timestamps. Use this to find specific content in long videos without loading the entire transcript.",
+  schema: SearchTranscriptSchema,
+  execute: execute$1,
+  publicSafe: true
 };
+const TRANSCRIPT_PREVIEW_LENGTH = 244;
 function truncateText(text, maxLength) {
   if (!text) return null;
   if (text.length <= maxLength) return text;
@@ -696,8 +455,8 @@ function truncateTranscripts(transcripts) {
     fullTranscript: truncateText(transcript2.fullTranscript, TRANSCRIPT_PREVIEW_LENGTH)
   }));
 }
-async function handleFindTranscripts(strapi, args) {
-  const validatedArgs = validateToolInput("find_transcripts", args);
+async function execute(args, strapi) {
+  const validatedArgs = FindTranscriptsSchema.parse(args);
   const { query, videoId, title, includeFullContent, page, pageSize, sort } = validatedArgs;
   const start = (page - 1) * pageSize;
   const filters = {};
@@ -725,39 +484,231 @@ async function handleFindTranscripts(strapi, args) {
   });
   const total = allMatching.length;
   const processedTranscripts = includeFullContent ? transcripts : truncateTranscripts(transcripts);
+  return {
+    data: processedTranscripts,
+    pagination: {
+      page,
+      pageSize,
+      total,
+      pageCount: Math.ceil(total / pageSize)
+    },
+    filters: {
+      query: query || null,
+      videoId: videoId || null,
+      title: title || null
+    },
+    ...!includeFullContent && { note: "Transcript content truncated to 244 chars. Use getTranscript for full content or set includeFullContent=true." }
+  };
+}
+const findTranscriptsTool = {
+  name: "findTranscripts",
+  description: "Search and filter transcripts based on query criteria. Returns multiple matching transcripts with truncated previews (244 chars). Use getTranscript for full content. Supports filtering by title, videoId, and full-text search.",
+  schema: FindTranscriptsSchema,
+  execute,
+  publicSafe: true
+};
+const tools$1 = [
+  fetchTranscriptTool,
+  listTranscriptsTool,
+  getTranscriptTool,
+  searchTranscriptTool,
+  findTranscriptsTool
+];
+const fetchTranscriptToolMcp = {
+  name: "fetch_transcript",
+  description: fetchTranscriptTool.description,
+  inputSchema: {
+    type: "object",
+    properties: {
+      videoId: {
+        type: "string",
+        description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
+      }
+    },
+    required: ["videoId"]
+  }
+};
+async function handleFetchTranscript(strapi, args) {
+  const result = await fetchTranscriptTool.execute(args, strapi);
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            data: processedTranscripts,
-            pagination: {
-              page,
-              pageSize,
-              total,
-              pageCount: Math.ceil(total / pageSize)
-            },
-            filters: {
-              query: query || null,
-              videoId: videoId || null,
-              title: title || null
-            },
-            ...!includeFullContent && { note: "Transcript content truncated to 244 chars. Use get_transcript for full content or set includeFullContent=true." }
-          },
-          null,
-          2
-        )
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const listTranscriptsToolMcp = {
+  name: "list_transcripts",
+  description: listTranscriptsTool.description,
+  inputSchema: {
+    type: "object",
+    properties: {
+      page: {
+        type: "number",
+        description: "Page number (starts at 1)"
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (max 100)"
+      },
+      sort: {
+        type: "string",
+        description: 'Sort order (e.g., "createdAt:desc", "title:asc")'
+      }
+    },
+    required: []
+  }
+};
+async function handleListTranscripts(strapi, args) {
+  const result = await listTranscriptsTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const getTranscriptToolMcp = {
+  name: "get_transcript",
+  description: getTranscriptTool.description,
+  inputSchema: {
+    type: "object",
+    properties: {
+      videoId: {
+        type: "string",
+        description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
+      },
+      includeFullTranscript: {
+        type: "boolean",
+        description: "Include the complete transcript text. Warning: may cause context overflow for long videos. Default: false"
+      },
+      includeTimecodes: {
+        type: "boolean",
+        description: "Include the transcript with timecodes array. Warning: significantly increases response size. Default: false"
+      },
+      startTime: {
+        type: "number",
+        description: "Start time in seconds for fetching a specific portion of the transcript"
+      },
+      endTime: {
+        type: "number",
+        description: "End time in seconds for fetching a specific portion of the transcript"
+      },
+      chunkIndex: {
+        type: "number",
+        description: "Chunk index (0-based) when paginating through transcript. Use with chunkSize to paginate through long videos."
+      },
+      chunkSize: {
+        type: "number",
+        description: "Chunk size in seconds. Overrides config default. Use with chunkIndex for pagination."
+      }
+    },
+    required: ["videoId"]
+  }
+};
+async function handleGetTranscript(strapi, args) {
+  const result = await getTranscriptTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const searchTranscriptToolMcp = {
+  name: "search_transcript",
+  description: searchTranscriptTool.description,
+  inputSchema: {
+    type: "object",
+    properties: {
+      videoId: {
+        type: "string",
+        description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
+      },
+      query: {
+        type: "string",
+        description: "Search query - keywords or phrases to find in the transcript"
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return (default: 5, max: 20)"
+      }
+    },
+    required: ["videoId", "query"]
+  }
+};
+async function handleSearchTranscript(strapi, args) {
+  const result = await searchTranscriptTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const findTranscriptsToolMcp = {
+  name: "find_transcripts",
+  description: findTranscriptsTool.description,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query to match against title or transcript content"
+      },
+      videoId: {
+        type: "string",
+        description: "Filter by specific video ID (partial match supported)"
+      },
+      title: {
+        type: "string",
+        description: "Filter by title (partial match, case-insensitive)"
+      },
+      includeFullContent: {
+        type: "boolean",
+        description: "Set to true to include full transcript content. Default: false. Warning: may cause context overflow with multiple results."
+      },
+      page: {
+        type: "number",
+        description: "Page number (starts at 1)"
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (max 100)"
+      },
+      sort: {
+        type: "string",
+        description: 'Sort order (e.g., "createdAt:desc", "title:asc")'
+      }
+    },
+    required: []
+  }
+};
+async function handleFindTranscripts(strapi, args) {
+  const result = await findTranscriptsTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
       }
     ]
   };
 }
 const tools = [
-  fetchTranscriptTool,
-  listTranscriptsTool,
-  getTranscriptTool,
-  searchTranscriptTool,
-  findTranscriptsTool
+  fetchTranscriptToolMcp,
+  listTranscriptsToolMcp,
+  getTranscriptToolMcp,
+  searchTranscriptToolMcp,
+  findTranscriptsToolMcp
 ];
 const toolHandlers = {
   fetch_transcript: handleFetchTranscript,
@@ -1452,8 +1403,14 @@ const service = ({ strapi }) => ({
     return transcriptData;
   }
 });
+const aiTools = ({ strapi }) => ({
+  getTools() {
+    return tools$1;
+  }
+});
 const services = {
-  service
+  service,
+  "ai-tools": aiTools
 };
 const index = {
   register,
@@ -1468,4 +1425,3 @@ const index = {
   middlewares
 };
 module.exports = index;
-//# sourceMappingURL=index.js.map