yt-transcript-strapi-plugin 0.1.4 → 0.2.0

package/dist/server/index.mjs

@@ -1,10 +1,10 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
+import { ProxyAgent, fetch as fetch$1 } from "undici";
 import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { Innertube } from "youtubei.js";
-import { ProxyAgent, fetch as fetch$1 } from "undici";
 const FetchTranscriptSchema = z.object({
   videoId: z.string().min(1, "Video ID or URL is required")
 });
@@ -36,26 +36,6 @@ const FindTranscriptsSchema = z.object({
   pageSize: z.number().int().min(1).max(100).optional().default(25),
   sort: 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)) {
@@ -73,20 +53,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];
@@ -120,11 +86,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;
@@ -135,18 +101,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) {
@@ -159,46 +114,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({
@@ -210,65 +136,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(
@@ -292,8 +174,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,
@@ -316,20 +198,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 || [];
@@ -395,7 +266,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).";
     }
@@ -405,42 +276,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);
@@ -520,8 +368,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;
@@ -534,77 +382,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);
@@ -616,74 +420,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;
@@ -695,8 +454,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 = {};
@@ -724,39 +483,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,
@@ -827,6 +778,26 @@ function createMcpServer(strapi) {
 }
 const PLUGIN_ID = "yt-transcript-strapi-plugin";
 const OAUTH_PLUGIN_ID = "strapi-oauth-mcp-manager";
+async function testProxyConnection(proxyUrl) {
+  try {
+    const proxyAgent = new ProxyAgent(proxyUrl);
+    const response = await fetch$1("https://httpbin.org/ip", {
+      dispatcher: proxyAgent,
+      signal: AbortSignal.timeout(1e4)
+      // 10 second timeout
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}` };
+    }
+    const data = await response.json();
+    return { success: true, ip: data.origin };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function createFallbackAuthMiddleware(strapi) {
   const mcpPath = `/api/${PLUGIN_ID}/mcp`;
   return async (ctx, next) => {
@@ -852,6 +823,21 @@ const bootstrap = async ({ strapi }) => {
   const plugin = strapi.plugin(PLUGIN_ID);
   plugin.createMcpServer = () => createMcpServer(strapi);
   plugin.sessions = /* @__PURE__ */ new Map();
+  const pluginConfig = strapi.config.get("plugin::yt-transcript-strapi-plugin");
+  if (pluginConfig?.proxyUrl) {
+    const maskedUrl = pluginConfig.proxyUrl.replace(/:([^@:]+)@/, ":****@");
+    strapi.log.info(`[${PLUGIN_ID}] Proxy configured: ${maskedUrl}`);
+    testProxyConnection(pluginConfig.proxyUrl).then((result) => {
+      if (result.success) {
+        strapi.log.info(`[${PLUGIN_ID}] ✓ Proxy connection successful - Outbound IP: ${result.ip}`);
+      } else {
+        strapi.log.error(`[${PLUGIN_ID}] ✗ Proxy connection FAILED: ${result.error}`);
+        strapi.log.error(`[${PLUGIN_ID}] YouTube requests will likely fail. Check your proxy credentials and URL.`);
+      }
+    });
+  } else {
+    strapi.log.warn(`[${PLUGIN_ID}] No proxy configured - YouTube may block requests. Set PROXY_URL in .env`);
+  }
   const oauthPlugin = strapi.plugin(OAUTH_PLUGIN_ID);
   if (oauthPlugin) {
     strapi.log.info(`[${PLUGIN_ID}] OAuth manager detected - OAuth + API token auth enabled`);
@@ -1152,19 +1138,57 @@ function createProxyFetch(proxyUrl) {
     return void 0;
   }
   const proxyAgent = new ProxyAgent(proxyUrl);
+  const maskedProxyUrl = proxyUrl.replace(/:([^@:]+)@/, ":****@");
   return async (input, init) => {
+    let url;
+    let method;
+    let headers = {};
+    let body;
     if (isRequestLike(input)) {
-      const url = input.url;
-      return fetch$1(url, {
-        method: input.method,
-        headers: input.headers,
-        body: input.body,
-        ...init,
-        dispatcher: proxyAgent
-      });
+      const request = input;
+      url = request.url;
+      method = init?.method || request.method || "GET";
+      if (request.headers && typeof request.headers.forEach === "function") {
+        request.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+      }
+      if (init?.headers) {
+        const initHeaders = init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers;
+        headers = { ...headers, ...initHeaders };
+      }
+      if (init?.body !== void 0) {
+        body = init.body;
+      } else if (method !== "GET" && method !== "HEAD" && request.body) {
+        try {
+          const cloned = request.clone();
+          body = await cloned.text();
+        } catch {
+        }
+      }
+    } else {
+      url = input instanceof URL ? input.toString() : input;
+      method = init?.method || "GET";
+      if (init?.headers) {
+        headers = init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers;
+      }
+      body = init?.body;
+    }
+    const options2 = {
+      method,
+      headers,
+      dispatcher: proxyAgent
+    };
+    if (body && method !== "GET" && method !== "HEAD") {
+      options2.body = body;
+    }
+    const urlPath = new URL(url).pathname;
+    console.log(`[yt-transcript] Proxy ${method} ${urlPath} via ${maskedProxyUrl}`);
+    const response = await fetch$1(url, options2);
+    if (!response.ok) {
+      console.log(`[yt-transcript] Proxy response: ${response.status} ${response.statusText}`);
     }
-    const urlString = input instanceof URL ? input.toString() : input;
-    return fetch$1(urlString, { ...init, dispatcher: proxyAgent });
+    return response;
   };
 }
 function decodeHtmlEntities(text) {
@@ -1242,34 +1266,77 @@ async function fetchTimedTextXml(captionUrl, proxyFetch) {
 }
 async function fetchTranscriptFromYouTube(videoId, options2) {
   const proxyFetch = createProxyFetch(options2?.proxyUrl);
+  if (options2?.proxyUrl) {
+    const maskedUrl = options2.proxyUrl.replace(/:([^@:]+)@/, ":****@");
+    console.log(`[yt-transcript] Fetching video ${videoId} via proxy: ${maskedUrl}`);
+  } else {
+    console.log(`[yt-transcript] Fetching video ${videoId} without proxy`);
+  }
   const client = await Innertube.create({
     generate_session_locally: true,
     lang: "en",
     location: "US",
-    retrieve_player: false,
+    retrieve_player: true,
+    // Required to get caption tracks
     fetch: proxyFetch
   });
   const info2 = await client.getBasicInfo(videoId);
   const title = info2.basic_info?.title;
   const captionTracks = info2.captions?.caption_tracks;
+  const playabilityStatus = info2.playability_status;
+  console.log(`[yt-transcript] Video ${videoId} - Title: ${info2.basic_info?.title || "Unknown"}`);
+  console.log(`[yt-transcript] Video ${videoId} - Playability: ${playabilityStatus?.status || "Unknown"}`);
+  console.log(`[yt-transcript] Video ${videoId} - Caption tracks found: ${captionTracks?.length || 0}`);
   if (!captionTracks || captionTracks.length === 0) {
-    const reason = info2.playability_status?.reason;
+    const status = playabilityStatus?.status;
+    const reason = playabilityStatus?.reason;
+    const subreason = playabilityStatus?.messages?.[0] || playabilityStatus?.subreason;
+    console.log(`[yt-transcript] Video ${videoId} - No captions found`);
+    console.log(`[yt-transcript] Video ${videoId} - Playability status: ${status || "Unknown"}`);
+    if (reason) {
+      console.log(`[yt-transcript] Video ${videoId} - Playability reason: ${reason}`);
+    }
+    if (subreason) {
+      console.log(`[yt-transcript] Video ${videoId} - Playability subreason: ${subreason}`);
+    }
     if (reason && reason.includes("Sign in")) {
       throw new Error(
         "YouTube requires sign-in. This usually means the IP is blocked. Configure a residential proxy in the plugin settings."
       );
     }
-    throw new Error("No captions available for this video");
+    if (status === "ERROR" || status === "UNPLAYABLE") {
+      throw new Error(
+        `Video is not playable (status: ${status}). ${reason || "The video may be private, deleted, or unavailable in your region."}`
+      );
+    }
+    if (status === "LOGIN_REQUIRED") {
+      throw new Error(
+        "YouTube requires login to access this video. This usually indicates IP blocking. Configure a residential proxy in the plugin settings."
+      );
+    }
+    if (info2.captions) {
+      console.log(`[yt-transcript] Video ${videoId} - Captions object exists but no tracks available`);
+    } else {
+      console.log(`[yt-transcript] Video ${videoId} - No captions object in response`);
+    }
+    throw new Error(
+      `No captions available for this video. Playability: ${status || "Unknown"}. The video may not have captions enabled, or YouTube may be blocking the request. ` + (options2?.proxyUrl ? "" : "Try configuring a proxy in the plugin settings.")
+    );
   }
+  const availableLanguages = captionTracks.map((t) => `${t.language_code}${t.kind === "asr" ? " (auto)" : ""}`);
+  console.log(`[yt-transcript] Video ${videoId} - Available languages: ${availableLanguages.join(", ")}`);
   const englishTrack = captionTracks.find((t) => t.language_code === "en" && t.kind !== "asr") || captionTracks.find((t) => t.language_code?.startsWith("en")) || captionTracks[0];
   if (!englishTrack?.base_url) {
     throw new Error("No valid caption track URL found");
   }
+  console.log(`[yt-transcript] Video ${videoId} - Fetching caption track: ${englishTrack.language_code}`);
   const xml = await fetchTimedTextXml(englishTrack.base_url, proxyFetch);
   const segments = parseTimedTextXml(xml);
   if (segments.length === 0) {
     throw new Error("Failed to parse any transcript segments from XML");
   }
+  const transcriptLength = segments.map((s) => s.text).join(" ").length;
+  console.log(`[yt-transcript] Video ${videoId} - Success! ${segments.length} segments, ${transcriptLength} chars`);
   return {
     videoId,
     title,
@@ -1293,12 +1360,29 @@ const service = ({ strapi }) => ({
     if (!isValid) {
       return { error: "Invalid video ID", data: null };
     }
-    const pluginSettings = await strapi.config.get(
-      "plugin::yt-transcript-strapi-plugin"
-    );
+    const pluginConfigFromGet = strapi.config.get("plugin::yt-transcript-strapi-plugin");
+    const pluginInstance = strapi.plugin("yt-transcript-strapi-plugin");
+    const configFromPlugin = pluginInstance?.config;
+    strapi.log.info(`[yt-transcript] Config from strapi.config.get: ${JSON.stringify(pluginConfigFromGet)}`);
+    strapi.log.info(`[yt-transcript] Config from plugin.config: ${typeof configFromPlugin === "function" ? "function" : JSON.stringify(configFromPlugin)}`);
+    let proxyUrl;
+    if (typeof configFromPlugin === "function") {
+      proxyUrl = configFromPlugin("proxyUrl");
+      strapi.log.info(`[yt-transcript] proxyUrl from config function: ${proxyUrl ? "SET" : "NOT SET"}`);
+    }
+    if (!proxyUrl && pluginConfigFromGet) {
+      proxyUrl = pluginConfigFromGet.proxyUrl || pluginConfigFromGet.config?.proxyUrl;
+    }
+    if (proxyUrl) {
+      const maskedUrl = proxyUrl.replace(/:([^@:]+)@/, ":****@");
+      strapi.log.info(`[yt-transcript] Fetching transcript for ${identifier} via proxy: ${maskedUrl}`);
+    } else {
+      strapi.log.info(`[yt-transcript] Fetching transcript for ${identifier} (NO PROXY - check config)`);
+    }
     const transcriptData = await fetchTranscript(identifier, {
-      proxyUrl: pluginSettings?.proxyUrl
+      proxyUrl
     });
+    strapi.log.info(`[yt-transcript] Successfully fetched transcript for ${identifier}`);
     return {
       title: transcriptData.title,
       fullTranscript: transcriptData.fullTranscript,
@@ -1318,8 +1402,14 @@ const service = ({ strapi }) => ({
     return transcriptData;
   }
 });
+const aiTools = ({ strapi }) => ({
+  getTools() {
+    return tools$1;
+  }
+});
 const services = {
-  service
+  service,
+  "ai-tools": aiTools
 };
 const index = {
   register,