yt-transcript-strapi-plugin 0.0.21 → 0.0.22

package/dist/server/index.js

@@ -4,14 +4,10 @@ const types_js = require("@modelcontextprotocol/sdk/types.js");
 const zod = require("zod");
 const node_crypto = require("node:crypto");
 const streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-const textsplitters = require("@langchain/textsplitters");
-const prompts = require("@langchain/core/prompts");
-const openai = require("@langchain/openai");
 const youtubei_js = require("youtubei.js");
 const undici = require("undici");
 const FetchTranscriptSchema = zod.z.object({
-  videoId: zod.z.string().min(1, "Video ID or URL is required"),
-  generateReadable: zod.z.boolean().optional().default(false)
+  videoId: zod.z.string().min(1, "Video ID or URL is required")
 });
 const ListTranscriptsSchema = zod.z.object({
   page: zod.z.number().int().min(1).optional().default(1),
@@ -68,31 +64,26 @@ function extractYouTubeID(urlOrID) {
 }
 const fetchTranscriptTool = {
   name: "fetch_transcript",
-  description: "Fetch a transcript from YouTube for a given video ID or URL. Optionally generates a human-readable version using AI. The transcript is saved to the database for future retrieval.",
+  description: "Fetch a transcript from YouTube for a given video ID or URL. The transcript is saved to the database for future retrieval.",
   inputSchema: {
     type: "object",
     properties: {
       videoId: {
         type: "string",
         description: 'YouTube video ID (e.g., "dQw4w9WgXcQ") or full YouTube URL'
-      },
-      generateReadable: {
-        type: "boolean",
-        description: "If true, uses AI to add punctuation and formatting to make the transcript more readable. Requires OpenAI API key configuration.",
-        default: false
       }
     },
     required: ["videoId"]
   }
 };
-async function handleFetchTranscript(strapi2, args) {
+async function handleFetchTranscript(strapi, args) {
   const validatedArgs = validateToolInput("fetch_transcript", args);
-  const { videoId: videoIdOrUrl, generateReadable } = validatedArgs;
+  const { videoId: videoIdOrUrl } = validatedArgs;
   const videoId = extractYouTubeID(videoIdOrUrl);
   if (!videoId) {
     throw new Error(`Invalid YouTube video ID or URL: "${videoIdOrUrl}". Please provide a valid 11-character video ID or YouTube URL.`);
   }
-  const service2 = strapi2.plugin("yt-transcript-strapi-plugin").service("service");
+  const service2 = strapi.plugin("yt-transcript-strapi-plugin").service("service");
   const existingTranscript = await service2.findTranscript(videoId);
   if (existingTranscript) {
     return {
@@ -122,14 +113,6 @@ async function handleFetchTranscript(strapi2, args) {
     fullTranscript: transcriptData.fullTranscript,
     transcriptWithTimeCodes: transcriptData.transcriptWithTimeCodes
   };
-  if (generateReadable && transcriptData.fullTranscript) {
-    try {
-      const readableTranscript = await service2.generateHumanReadableTranscript(transcriptData.fullTranscript);
-      payload.readableTranscript = readableTranscript;
-    } catch (error) {
-      strapi2.log.warn("[yt-transcript-mcp] Failed to generate readable transcript:", error);
-    }
-  }
   const savedTranscript = await service2.saveTranscript(payload);
   return {
     content: [
@@ -173,17 +156,17 @@ const listTranscriptsTool = {
     required: []
   }
 };
-async function handleListTranscripts(strapi2, args) {
+async function handleListTranscripts(strapi, args) {
   const validatedArgs = validateToolInput("list_transcripts", args);
   const { page, pageSize, sort } = validatedArgs;
   const start = (page - 1) * pageSize;
-  const transcripts = await strapi2.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
+  const transcripts = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
     sort,
     limit: pageSize,
     start,
     fields: ["id", "documentId", "title", "videoId", "createdAt", "updatedAt"]
   });
-  const allTranscripts = await strapi2.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({});
+  const allTranscripts = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({});
   const total = allTranscripts.length;
   return {
     content: [
@@ -220,14 +203,14 @@ const getTranscriptTool = {
     required: ["videoId"]
   }
 };
-async function handleGetTranscript(strapi2, args) {
+async function handleGetTranscript(strapi, args) {
   const validatedArgs = validateToolInput("get_transcript", args);
   const { videoId: videoIdOrUrl } = validatedArgs;
   const videoId = extractYouTubeID(videoIdOrUrl);
   if (!videoId) {
     throw new Error(`Invalid YouTube video ID or URL: "${videoIdOrUrl}". Please provide a valid 11-character video ID or YouTube URL.`);
   }
-  const service2 = strapi2.plugin("yt-transcript-strapi-plugin").service("service");
+  const service2 = strapi.plugin("yt-transcript-strapi-plugin").service("service");
   const transcript2 = await service2.findTranscript(videoId);
   if (!transcript2) {
     return {
@@ -312,11 +295,10 @@ function truncateText(text, maxLength) {
 function truncateTranscripts(transcripts) {
   return transcripts.map((transcript2) => ({
     ...transcript2,
-    fullTranscript: truncateText(transcript2.fullTranscript, TRANSCRIPT_PREVIEW_LENGTH),
-    readableTranscript: truncateText(transcript2.readableTranscript, TRANSCRIPT_PREVIEW_LENGTH)
+    fullTranscript: truncateText(transcript2.fullTranscript, TRANSCRIPT_PREVIEW_LENGTH)
   }));
 }
-async function handleFindTranscripts(strapi2, args) {
+async function handleFindTranscripts(strapi, args) {
   const validatedArgs = validateToolInput("find_transcripts", args);
   const { query, videoId, title, includeFullContent, page, pageSize, sort } = validatedArgs;
   const start = (page - 1) * pageSize;
@@ -331,17 +313,16 @@ async function handleFindTranscripts(strapi2, args) {
     filters.$or = [
       { title: { $containsi: query } },
       { videoId: { $containsi: query } },
-      { fullTranscript: { $containsi: query } },
-      { readableTranscript: { $containsi: query } }
+      { fullTranscript: { $containsi: query } }
     ];
   }
-  const transcripts = await strapi2.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
+  const transcripts = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
     filters,
     sort,
     limit: pageSize,
     start
   });
-  const allMatching = await strapi2.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
+  const allMatching = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({
     filters
   });
   const total = allMatching.length;
@@ -385,7 +366,7 @@ const toolHandlers = {
   get_transcript: handleGetTranscript,
   find_transcripts: handleFindTranscripts
 };
-async function handleToolCall(strapi2, request) {
+async function handleToolCall(strapi, request) {
   const { name, arguments: args } = request.params;
   const handler = toolHandlers[name];
   if (!handler) {
@@ -393,13 +374,13 @@ async function handleToolCall(strapi2, request) {
   }
   const startTime = Date.now();
   try {
-    const result = await handler(strapi2, args || {});
+    const result = await handler(strapi, args || {});
     const duration = Date.now() - startTime;
-    strapi2.log.debug(`[yt-transcript-mcp] Tool ${name} executed successfully in ${duration}ms`);
+    strapi.log.debug(`[yt-transcript-mcp] Tool ${name} executed successfully in ${duration}ms`);
     return result;
   } catch (error) {
     const duration = Date.now() - startTime;
-    strapi2.log.error(`[yt-transcript-mcp] Tool ${name} failed after ${duration}ms`, {
+    strapi.log.error(`[yt-transcript-mcp] Tool ${name} failed after ${duration}ms`, {
       error: error instanceof Error ? error.message : String(error)
     });
     return {
@@ -420,7 +401,7 @@ async function handleToolCall(strapi2, request) {
     };
   }
 }
-function createMcpServer(strapi2) {
+function createMcpServer(strapi) {
   const server = new index_js.Server(
     {
       name: "yt-transcript-mcp",
@@ -433,28 +414,28 @@ function createMcpServer(strapi2) {
     }
   );
   server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
-    strapi2.log.debug("[yt-transcript-mcp] Listing tools");
+    strapi.log.debug("[yt-transcript-mcp] Listing tools");
     return { tools };
   });
   server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
-    strapi2.log.debug(`[yt-transcript-mcp] Tool call: ${request.params.name}`);
-    return handleToolCall(strapi2, request);
+    strapi.log.debug(`[yt-transcript-mcp] Tool call: ${request.params.name}`);
+    return handleToolCall(strapi, request);
   });
-  strapi2.log.info("[yt-transcript-mcp] MCP server created with tools:", {
+  strapi.log.info("[yt-transcript-mcp] MCP server created with tools:", {
     tools: tools.map((t) => t.name)
   });
   return server;
 }
-const bootstrap = async ({ strapi: strapi2 }) => {
-  const plugin = strapi2.plugin("yt-transcript-strapi-plugin");
-  plugin.createMcpServer = () => createMcpServer(strapi2);
+const bootstrap = async ({ strapi }) => {
+  const plugin = strapi.plugin("yt-transcript-strapi-plugin");
+  plugin.createMcpServer = () => createMcpServer(strapi);
   plugin.sessions = /* @__PURE__ */ new Map();
-  strapi2.log.info("[yt-transcript-mcp] MCP plugin initialized");
-  strapi2.log.info("[yt-transcript-mcp] MCP endpoint available at: /api/yt-transcript-strapi-plugin/mcp");
+  strapi.log.info("[yt-transcript-mcp] MCP plugin initialized");
+  strapi.log.info("[yt-transcript-mcp] MCP endpoint available at: /api/yt-transcript-strapi-plugin/mcp");
 };
-const destroy = ({ strapi: strapi2 }) => {
+const destroy = ({ strapi }) => {
 };
-const register = ({ strapi: strapi2 }) => {
+const register = ({ strapi }) => {
 };
 const config = {
   default: {
@@ -513,9 +494,6 @@ const attributes = {
   },
   transcriptWithTimeCodes: {
     type: "json"
-  },
-  readableTranscript: {
-    type: "richtext"
   }
 };
 const schema = {
@@ -532,41 +510,34 @@ const transcript = {
 const contentTypes = {
   transcript
 };
-const controller = ({ strapi: strapi2 }) => ({
+const controller = ({ strapi }) => ({
   async getTranscript(ctx) {
     const videoId = extractYouTubeID(ctx.params.videoId);
     if (!videoId) {
       return ctx.body = { error: "Invalid YouTube URL or ID", data: null };
     }
-    const found = await strapi2.plugin("yt-transcript-strapi-plugin").service("service").findTranscript(videoId);
+    const found = await strapi.plugin("yt-transcript-strapi-plugin").service("service").findTranscript(videoId);
     if (found) {
       return ctx.body = { data: found };
     }
-    const transcriptData = await strapi2.plugin("yt-transcript-strapi-plugin").service("service").getTranscript(videoId);
-    let readableTranscript = null;
-    try {
-      readableTranscript = await strapi2.plugin("yt-transcript-strapi-plugin").service("service").generateHumanReadableTranscript(transcriptData.fullTranscript);
-    } catch (error) {
-      strapi2.log.debug("[yt-transcript] Readable transcript generation skipped");
-    }
+    const transcriptData = await strapi.plugin("yt-transcript-strapi-plugin").service("service").getTranscript(videoId);
     const payload = {
       videoId,
       title: transcriptData?.title || "No title found",
       fullTranscript: transcriptData?.fullTranscript,
-      transcriptWithTimeCodes: transcriptData?.transcriptWithTimeCodes,
-      readableTranscript
+      transcriptWithTimeCodes: transcriptData?.transcriptWithTimeCodes
     };
-    const transcript2 = await strapi2.plugin("yt-transcript-strapi-plugin").service("service").saveTranscript(payload);
+    const transcript2 = await strapi.plugin("yt-transcript-strapi-plugin").service("service").saveTranscript(payload);
     ctx.body = { data: transcript2 };
   }
 });
-const mcpController = ({ strapi: strapi2 }) => ({
+const mcpController = ({ strapi }) => ({
   /**
    * Handle MCP requests (POST, GET, DELETE)
    * Creates a new server+transport per session for proper isolation
    */
   async handle(ctx) {
-    const plugin = strapi2.plugin("yt-transcript-strapi-plugin");
+    const plugin = strapi.plugin("yt-transcript-strapi-plugin");
     if (!plugin.createMcpServer) {
       ctx.status = 503;
       ctx.body = {
@@ -586,12 +557,12 @@ const mcpController = ({ strapi: strapi2 }) => ({
         await server.connect(transport);
         session = { server, transport, createdAt: Date.now() };
         plugin.sessions.set(sessionId, session);
-        strapi2.log.debug(`[yt-transcript-mcp] New session created: ${sessionId}`);
+        strapi.log.debug(`[yt-transcript-mcp] New session created: ${sessionId}`);
       }
       await session.transport.handleRequest(ctx.req, ctx.res, ctx.request.body);
       ctx.respond = false;
     } catch (error) {
-      strapi2.log.error("[yt-transcript-mcp] Error handling MCP request", {
+      strapi.log.error("[yt-transcript-mcp] Error handling MCP request", {
         error: error instanceof Error ? error.message : String(error),
         method: ctx.method,
         path: ctx.path
@@ -671,18 +642,6 @@ const routes = {
     routes: [...admin]
   }
 };
-async function initializeModel({
-  openAIApiKey,
-  model,
-  temp
-}) {
-  return new openai.ChatOpenAI({
-    temperature: temp,
-    openAIApiKey,
-    modelName: model,
-    maxTokens: 1e3
-  });
-}
 function isRequestLike(input) {
   return typeof input === "object" && input !== null && "url" in input && typeof input.url === "string" && "method" in input;
 }
@@ -825,49 +784,14 @@ const fetchTranscript = async (videoId, options2) => {
     );
   }
 };
-async function processTextChunks(chunks, model) {
-  const punctuationPrompt = prompts.PromptTemplate.fromTemplate(
-    "Add proper punctuation and capitalization to the following text chunk:\n\n{chunk}"
-  );
-  const punctuationChain = punctuationPrompt.pipe(model);
-  const processedChunks = await Promise.all(
-    chunks.map(async (chunk) => {
-      const result = await punctuationChain.invoke({ chunk });
-      return result.content;
-    })
-  );
-  return processedChunks.join(" ");
-}
-async function generateModifiedTranscript(rawTranscript) {
-  const pluginSettings = await strapi.config.get(
-    "plugin::yt-transcript-strapi-plugin"
-  );
-  if (!pluginSettings.openAIApiKey || !pluginSettings.model || !pluginSettings.temp || !pluginSettings.maxTokens) {
-    throw new Error("Missing required configuration for YTTranscript");
-  }
-  const chatModel = await initializeModel({
-    openAIApiKey: pluginSettings.openAIApiKey,
-    model: pluginSettings.model,
-    temp: pluginSettings.temp,
-    maxTokens: pluginSettings.maxTokens
-  });
-  const splitter = new textsplitters.TokenTextSplitter({
-    chunkSize: 1e3,
-    chunkOverlap: 200
-  });
-  const transcriptChunks = await splitter.createDocuments([rawTranscript]);
-  const chunkTexts = transcriptChunks.map((chunk) => chunk.pageContent);
-  const modifiedTranscript = await processTextChunks(chunkTexts, chatModel);
-  return modifiedTranscript;
-}
-const service = ({ strapi: strapi2 }) => ({
+const service = ({ strapi }) => ({
   async getTranscript(identifier) {
     const youtubeIdRegex = /^[a-zA-Z0-9_-]{11}$/;
     const isValid = youtubeIdRegex.test(identifier);
     if (!isValid) {
       return { error: "Invalid video ID", data: null };
     }
-    const pluginSettings = await strapi2.config.get(
+    const pluginSettings = await strapi.config.get(
       "plugin::yt-transcript-strapi-plugin"
     );
     const transcriptData = await fetchTranscript(identifier, {
@@ -880,20 +804,16 @@ const service = ({ strapi: strapi2 }) => ({
     };
   },
   async saveTranscript(payload) {
-    return await strapi2.documents("plugin::yt-transcript-strapi-plugin.transcript").create({
+    return await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").create({
       data: payload
     });
   },
   async findTranscript(videoId) {
-    const transcriptData = await strapi2.documents("plugin::yt-transcript-strapi-plugin.transcript").findFirst({
+    const transcriptData = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findFirst({
       filters: { videoId }
     });
     if (!transcriptData) return null;
     return transcriptData;
-  },
-  async generateHumanReadableTranscript(transcript2) {
-    const modifiedTranscript = await generateModifiedTranscript(transcript2);
-    return modifiedTranscript;
   }
 });
 const services = {