yt-transcript-strapi-plugin 0.1.3 → 0.1.5

package/README.md

@@ -1,15 +1,18 @@
 # YouTube Transcript Strapi Plugin
 
-A Strapi plugin that provides YouTube transcript extraction with **MCP (Model Context Protocol)** support for AI assistants like ChatGPT and Claude.
+A Strapi v5 plugin that extracts transcripts from YouTube videos and exposes them via MCP (Model Context Protocol) for AI assistants like ChatGPT and Claude.
 
-## Features
+## What It Does
 
-- Extract transcripts from YouTube videos
-- MCP server endpoint for AI assistant integration
-- OAuth 2.0 authentication support (for ChatGPT)
-- API token authentication support (for Claude Desktop)
-- Automatic transcript chunking and search
-- Works with `strapi-oauth-mcp-manager` for centralized OAuth
+This plugin allows AI assistants to:
+
+- **Fetch transcripts** from any YouTube video with captions (auto-generated or manual)
+- **Store transcripts** in Strapi's database for faster repeated access
+- **Search within transcripts** using BM25 relevance scoring
+- **Paginate long transcripts** in time-based chunks to manage token usage
+- **List and find stored transcripts** across your Strapi instance
+
+The plugin uses YouTube's internal API via `youtubei.js` to extract caption data, parsing the timedtext XML to provide accurate timestamps for each segment.
 
 ## Installation
 
@@ -17,68 +20,225 @@ A Strapi plugin that provides YouTube transcript extraction with **MCP (Model Co
 npm install yt-transcript-strapi-plugin
 ```
 
+Or with yarn:
+
+```bash
+yarn add yt-transcript-strapi-plugin
+```
+
+## Setup in Strapi
+
+### 1. Enable the Plugin
+
+Add the plugin to your Strapi configuration in `config/plugins.ts` (or `config/plugins.js`):
+
+```typescript
+export default () => ({
+  'yt-transcript-strapi-plugin': {
+    enabled: true,
+    config: {
+      // See Configuration section below
+    },
+  },
+});
+```
+
+### 2. Rebuild Strapi
+
+After adding the plugin, rebuild your Strapi application:
+
+```bash
+npm run build
+npm run develop
+```
+
+### 3. Configure Permissions
+
+Go to **Settings > Users & Permissions > Roles** in the Strapi admin panel.
+
+For the **Public** role (or your preferred role), enable:
+- `yt-transcript-strapi-plugin` > `mcp` (for MCP endpoint access)
+
+Alternatively, use **API Tokens** for authentication (recommended for production).
+
 ## Configuration
 
-Add the plugin to your `config/plugins.ts`:
+All configuration options with their defaults:
+
+```typescript
+export default () => ({
+  'yt-transcript-strapi-plugin': {
+    enabled: true,
+    config: {
+      // Proxy URL for YouTube requests (recommended for production)
+      proxyUrl: process.env.PROXY_URL || '',
+
+      // Chunk size for transcript pagination (default: 5 minutes)
+      chunkSizeSeconds: 300,
+
+      // Preview length in characters (default: 500)
+      previewLength: 500,
+
+      // Auto-load full transcript if under this character count (default: 50000)
+      maxFullTranscriptLength: 50000,
+
+      // Segment size for search scoring in seconds (default: 30)
+      searchSegmentSeconds: 30,
+    },
+  },
+});
+```
+
+### Configuration Options Explained
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `proxyUrl` | string | `''` | HTTP/HTTPS proxy URL for YouTube requests |
+| `chunkSizeSeconds` | number | `300` | Time-based chunk size for paginating transcripts (min: 30) |
+| `previewLength` | number | `500` | Number of characters to include in transcript previews (min: 100) |
+| `maxFullTranscriptLength` | number | `50000` | Transcripts under this length are returned in full (min: 1000) |
+| `searchSegmentSeconds` | number | `30` | Segment duration for BM25 search scoring (min: 10) |
+
+## Proxy Configuration
+
+### Why Use a Proxy?
+
+YouTube may block requests from server IPs, especially:
+- Cloud hosting providers (AWS, GCP, Azure, etc.)
+- Data center IPs
+- IPs with high request volumes
+
+If you see errors like "YouTube requires sign-in" or empty responses, you likely need a proxy.
+
+### Setting Up a Proxy
+
+1. **Get a residential proxy** from a provider like:
+   - Bright Data
+   - Oxylabs
+   - Smartproxy
+   - IPRoyal
+
+2. **Configure the proxy URL** in your environment:
+
+```bash
+# .env file
+PROXY_URL=http://username:password@proxy.example.com:8080
+```
+
+3. **Reference it in your plugin config**:
 
 ```typescript
 export default () => ({
   'yt-transcript-strapi-plugin': {
     enabled: true,
     config: {
-      proxyUrl: process.env.PROXY_URL,           // Optional: proxy for YouTube requests
-      chunkSizeSeconds: 300,                      // Chunk size for pagination (5 minutes)
-      previewLength: 500,                         // Preview length in characters
-      maxFullTranscriptLength: 50000,             // Auto-load full transcript if under this
-      searchSegmentSeconds: 30,                   // Segment size for search
+      proxyUrl: process.env.PROXY_URL,
     },
   },
 });
 ```
 
+### Proxy URL Format
+
+```
+http://username:password@hostname:port
+https://username:password@hostname:port
+```
+
+The plugin masks credentials in logs (showing `****` instead of the password).
+
+### Testing Without a Proxy
+
+For local development, you may not need a proxy if your home IP isn't blocked. The plugin works without a proxy configured—it will make direct requests to YouTube.
+
 ## MCP Endpoint
 
-The plugin exposes an MCP endpoint at:
+The plugin exposes an MCP-compatible endpoint at:
 
 ```
 /api/yt-transcript-strapi-plugin/mcp
 ```
 
+This endpoint implements the Model Context Protocol for AI assistant integration.
+
 ### Available MCP Tools
 
 | Tool | Description |
 |------|-------------|
-| `get_transcript_preview` | Get video metadata and transcript preview |
-| `get_transcript_chunk` | Get a specific chunk of the transcript |
-| `search_transcript` | Search within a transcript |
-| `get_full_transcript` | Get the complete transcript |
+| `fetch_transcript` | Fetch and store a transcript from a YouTube URL or video ID |
+| `get_transcript` | Get a stored transcript by ID (supports chunked pagination) |
+| `list_transcripts` | List all stored transcripts with pagination |
+| `find_transcripts` | Find transcripts by video ID or search term |
+| `search_transcript` | Search within a specific transcript using BM25 scoring |
+
+### Tool Details
+
+#### `fetch_transcript`
+Fetches a transcript from YouTube and stores it in the database.
+
+**Parameters:**
+- `url` (string, required): YouTube URL or video ID
+
+**Returns:** Transcript data with video title, full text, and timestamped segments.
+
+#### `get_transcript`
+Retrieves a stored transcript, optionally paginated by time chunks.
+
+**Parameters:**
+- `id` (number, required): Transcript database ID
+- `chunk` (number, optional): Chunk index for pagination (0-based)
+
+#### `search_transcript`
+Searches within a transcript using BM25 relevance scoring.
+
+**Parameters:**
+- `id` (number, required): Transcript database ID
+- `query` (string, required): Search terms
+
+**Returns:** Ranked segments matching the query with timestamps.
 
 ## Authentication
 
-### Option 1: OAuth 2.0 (ChatGPT)
+### Option 1: API Token (Recommended)
+
+Create an API token in Strapi Admin:
+
+1. Go to **Settings > API Tokens**
+2. Click **Create new API Token**
+3. Give it a name and select appropriate permissions
+4. Copy the token
+
+Use the token in requests:
+
+```bash
+curl -H "Authorization: Bearer YOUR_API_TOKEN" \
+  https://your-strapi.com/api/yt-transcript-strapi-plugin/mcp
+```
+
+### Option 2: OAuth 2.0 (for ChatGPT)
 
-For ChatGPT integration, use with `strapi-oauth-mcp-manager`:
+For ChatGPT integration, use with the `strapi-oauth-mcp-manager` plugin:
 
-1. Install and enable `strapi-oauth-mcp-manager` plugin
+1. Install and enable `strapi-oauth-mcp-manager`
 2. Create an OAuth client in Strapi admin
-3. Configure ChatGPT with:
-   - MCP Server URL: `https://your-domain/api/yt-transcript-strapi-plugin/mcp`
-   - OAuth Client ID and Secret from Strapi admin
+3. Configure ChatGPT with the OAuth credentials
 
 The plugin automatically registers with the OAuth manager on startup.
 
-### Option 2: API Token (Claude Desktop)
+## Connecting AI Assistants
+
+### Claude Desktop
 
-For Claude Desktop, use direct API token authentication:
+Add to your Claude Desktop config (`~/.claude/claude_desktop_config.json`):
 
 ```json
 {
   "mcpServers": {
-    "yt-transcript": {
+    "youtube-transcripts": {
       "command": "npx",
       "args": [
         "mcp-remote",
-        "https://your-server.com/api/yt-transcript-strapi-plugin/mcp",
+        "https://your-strapi.com/api/yt-transcript-strapi-plugin/mcp",
         "--header",
         "Authorization: Bearer YOUR_STRAPI_API_TOKEN"
       ]
@@ -87,15 +247,52 @@ For Claude Desktop, use direct API token authentication:
 }
 ```
 
-Get your API token from: Strapi Admin > Settings > API Tokens
+### ChatGPT
 
-## Usage with AI Assistants
+Use the OAuth flow with `strapi-oauth-mcp-manager`. Configure your ChatGPT plugin with:
+
+- **MCP Server URL:** `https://your-strapi.com/api/yt-transcript-strapi-plugin/mcp`
+- **OAuth Client ID:** From Strapi OAuth manager
+- **OAuth Client Secret:** From Strapi OAuth manager
+
+## Example Usage
 
 Once connected, you can ask your AI assistant:
 
-- "Get the transcript from this YouTube video: [URL]"
-- "Search for mentions of 'machine learning' in this video"
-- "Summarize the main points from this YouTube video"
+- "Get the transcript from https://youtube.com/watch?v=VIDEO_ID"
+- "Search for mentions of 'machine learning' in transcript #5"
+- "List all stored transcripts"
+- "Summarize the key points from this YouTube video: [URL]"
+
+## Troubleshooting
+
+### "YouTube requires sign-in" Error
+
+Your server IP is likely blocked. Configure a residential proxy (see Proxy Configuration above).
+
+### Empty or No Captions
+
+The video may not have captions available. Check if:
+- The video has auto-generated or manual captions on YouTube
+- The video is public and not age-restricted
+- The video is available in your region
+
+### Timeout Errors
+
+Long videos may take time to process. The plugin logs progress—check your Strapi logs for details.
+
+### Debug Logging
+
+The plugin logs detailed information during transcript fetching:
+
+```
+[yt-transcript] Fetching video ABC123 via proxy: http://user:****@proxy.example.com:8080
+[yt-transcript] Video ABC123 - Title: Example Video
+[yt-transcript] Video ABC123 - Playability: OK
+[yt-transcript] Video ABC123 - Caption tracks found: 2
+[yt-transcript] Video ABC123 - Available languages: en, en (auto)
+[yt-transcript] Video ABC123 - Success! 150 segments, 4532 chars
+```
 
 ## Requirements
 

package/dist/_chunks/en-B4KWt_jN.js

@@ -2,3 +2,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const en = {};
 exports.default = en;
+//# sourceMappingURL=en-B4KWt_jN.js.map

package/dist/_chunks/en-B4KWt_jN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"en-B4KWt_jN.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/_chunks/en-Byx4XI2L.mjs

@@ -2,3 +2,4 @@ const en = {};
 export {
   en as default
 };
+//# sourceMappingURL=en-Byx4XI2L.mjs.map

package/dist/_chunks/en-Byx4XI2L.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"en-Byx4XI2L.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/admin/index.js

@@ -55,3 +55,4 @@ const index = {
   }
 };
 module.exports = index;
+//# sourceMappingURL=index.js.map

package/dist/admin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../admin/src/pluginId.ts","../../admin/src/utils/getTranslation.ts","../../admin/src/components/Initializer.tsx","../../admin/src/index.ts"],"sourcesContent":["export const PLUGIN_ID = 'yt-transcript-strapi-plugin';\n","import { PLUGIN_ID } from '../pluginId';\n\nconst getTranslation = (id: string) => `${PLUGIN_ID}.${id}`;\n\nexport { getTranslation };\n","import { useEffect, useRef } from 'react';\n\nimport { PLUGIN_ID } from '../pluginId';\n\ntype InitializerProps = {\n  setPlugin: (id: string) => void;\n};\n\nconst Initializer = ({ setPlugin }: InitializerProps) => {\n  const ref = useRef(setPlugin);\n\n  useEffect(() => {\n    ref.current(PLUGIN_ID);\n  }, []);\n\n  return null;\n};\n\nexport { Initializer };\n","import { getTranslation } from './utils/getTranslation';\nimport { PLUGIN_ID } from './pluginId';\nimport { Initializer } from './components/Initializer';\n// import { PluginIcon } from './components/PluginIcon';\n\nexport default {\n  register(app: any) {\n    // app.addMenuLink({\n    //   to: `plugins/${PLUGIN_ID}`,\n    //   icon: PluginIcon,\n    //   intlLabel: {\n    //     id: `${PLUGIN_ID}.plugin.name`,\n    //     defaultMessage: PLUGIN_ID,\n    //   },\n    //   Component: async () => {\n    //     const { App } = await import('./pages/App');\n\n    //     return App;\n    //   },\n    // });\n\n    app.registerPlugin({\n      id: PLUGIN_ID,\n      initializer: Initializer,\n      isReady: false,\n      name: PLUGIN_ID,\n    });\n  },\n\n  async registerTrads(app: any) {\n    const { locales } = app;\n\n    const importedTranslations = await Promise.all(\n      (locales as string[]).map((locale) => {\n        return import(`./translations/${locale}.json`)\n          .then(({ default: data }) => {\n            return {\n              data: getTranslation(data),\n              locale,\n            };\n          })\n          .catch(() => {\n            return {\n              data: {},\n              locale,\n            };\n          });\n      })\n    );\n\n    return importedTranslations;\n  },\n};\n"],"names":["useRef","useEffect"],"mappings":";;;;;;;;;;;;;;;;;;AAAO,MAAM,YAAY;ACEzB,MAAM,iBAAiB,CAAC,OAAe,GAAG,SAAS,IAAI,EAAE;ACMzD,MAAM,cAAc,CAAC,EAAE,gBAAkC;AACvD,QAAM,MAAMA,MAAAA,OAAO,SAAS;AAE5BC,QAAAA,UAAU,MAAM;AACd,QAAI,QAAQ,SAAS;AAAA,EACvB,GAAG,CAAA,CAAE;AAEL,SAAO;AACT;ACXA,MAAA,QAAe;AAAA,EACb,SAAS,KAAU;AAejB,QAAI,eAAe;AAAA,MACjB,IAAI;AAAA,MACJ,aAAa;AAAA,MACb,SAAS;AAAA,MACT,MAAM;AAAA,IAAA,CACP;AAAA,EACH;AAAA,EAEA,MAAM,cAAc,KAAU;AAC5B,UAAM,EAAE,YAAY;AAEpB,UAAM,uBAAuB,MAAM,QAAQ;AAAA,MACxC,QAAqB,IAAI,CAAC,WAAW;AACpC,eAAO,qCAAA,uBAAA,OAAA,EAAA,0BAAA,MAAA,QAAA,QAAA,EAAA,KAAA,MAAA,QAAA,2BAAA,CAAA,EAAA,CAAA,GAAA,kBAAA,MAAA,SAAA,CAAA,EACJ,KAAK,CAAC,EAAE,SAAS,WAAW;AAC3B,iBAAO;AAAA,YACL,MAAM,eAAe,IAAI;AAAA,YACzB;AAAA,UAAA;AAAA,QAEJ,CAAC,EACA,MAAM,MAAM;AACX,iBAAO;AAAA,YACL,MAAM,CAAA;AAAA,YACN;AAAA,UAAA;AAAA,QAEJ,CAAC;AAAA,MACL,CAAC;AAAA,IAAA;AAGH,WAAO;AAAA,EACT;AACF;;"}

package/dist/admin/index.mjs

@@ -56,3 +56,4 @@ const index = {
 export {
   index as default
 };
+//# sourceMappingURL=index.mjs.map

package/dist/admin/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../admin/src/pluginId.ts","../../admin/src/utils/getTranslation.ts","../../admin/src/components/Initializer.tsx","../../admin/src/index.ts"],"sourcesContent":["export const PLUGIN_ID = 'yt-transcript-strapi-plugin';\n","import { PLUGIN_ID } from '../pluginId';\n\nconst getTranslation = (id: string) => `${PLUGIN_ID}.${id}`;\n\nexport { getTranslation };\n","import { useEffect, useRef } from 'react';\n\nimport { PLUGIN_ID } from '../pluginId';\n\ntype InitializerProps = {\n  setPlugin: (id: string) => void;\n};\n\nconst Initializer = ({ setPlugin }: InitializerProps) => {\n  const ref = useRef(setPlugin);\n\n  useEffect(() => {\n    ref.current(PLUGIN_ID);\n  }, []);\n\n  return null;\n};\n\nexport { Initializer };\n","import { getTranslation } from './utils/getTranslation';\nimport { PLUGIN_ID } from './pluginId';\nimport { Initializer } from './components/Initializer';\n// import { PluginIcon } from './components/PluginIcon';\n\nexport default {\n  register(app: any) {\n    // app.addMenuLink({\n    //   to: `plugins/${PLUGIN_ID}`,\n    //   icon: PluginIcon,\n    //   intlLabel: {\n    //     id: `${PLUGIN_ID}.plugin.name`,\n    //     defaultMessage: PLUGIN_ID,\n    //   },\n    //   Component: async () => {\n    //     const { App } = await import('./pages/App');\n\n    //     return App;\n    //   },\n    // });\n\n    app.registerPlugin({\n      id: PLUGIN_ID,\n      initializer: Initializer,\n      isReady: false,\n      name: PLUGIN_ID,\n    });\n  },\n\n  async registerTrads(app: any) {\n    const { locales } = app;\n\n    const importedTranslations = await Promise.all(\n      (locales as string[]).map((locale) => {\n        return import(`./translations/${locale}.json`)\n          .then(({ default: data }) => {\n            return {\n              data: getTranslation(data),\n              locale,\n            };\n          })\n          .catch(() => {\n            return {\n              data: {},\n              locale,\n            };\n          });\n      })\n    );\n\n    return importedTranslations;\n  },\n};\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAO,MAAM,YAAY;ACEzB,MAAM,iBAAiB,CAAC,OAAe,GAAG,SAAS,IAAI,EAAE;ACMzD,MAAM,cAAc,CAAC,EAAE,gBAAkC;AACvD,QAAM,MAAM,OAAO,SAAS;AAE5B,YAAU,MAAM;AACd,QAAI,QAAQ,SAAS;AAAA,EACvB,GAAG,CAAA,CAAE;AAEL,SAAO;AACT;ACXA,MAAA,QAAe;AAAA,EACb,SAAS,KAAU;AAejB,QAAI,eAAe;AAAA,MACjB,IAAI;AAAA,MACJ,aAAa;AAAA,MACb,SAAS;AAAA,MACT,MAAM;AAAA,IAAA,CACP;AAAA,EACH;AAAA,EAEA,MAAM,cAAc,KAAU;AAC5B,UAAM,EAAE,YAAY;AAEpB,UAAM,uBAAuB,MAAM,QAAQ;AAAA,MACxC,QAAqB,IAAI,CAAC,WAAW;AACpC,eAAO,qCAAA,uBAAA,OAAA,EAAA,0BAAA,MAAA,OAAA,4BAAA,EAAA,CAAA,GAAA,kBAAA,MAAA,SAAA,CAAA,EACJ,KAAK,CAAC,EAAE,SAAS,WAAW;AAC3B,iBAAO;AAAA,YACL,MAAM,eAAe,IAAI;AAAA,YACzB;AAAA,UAAA;AAAA,QAEJ,CAAC,EACA,MAAM,MAAM;AACX,iBAAO;AAAA,YACL,MAAM,CAAA;AAAA,YACN;AAAA,UAAA;AAAA,QAEJ,CAAC;AAAA,MACL,CAAC;AAAA,IAAA;AAGH,WAAO;AAAA,EACT;AACF;"}

package/dist/server/index.js

@@ -2,10 +2,10 @@
 const index_js = require("@modelcontextprotocol/sdk/server/index.js");
 const types_js = require("@modelcontextprotocol/sdk/types.js");
 const zod = require("zod");
+const undici = require("undici");
 const node_crypto = require("node:crypto");
 const streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 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")
 });
@@ -828,6 +828,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 undici.ProxyAgent(proxyUrl);
+    const response = await undici.fetch("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) => {
@@ -853,6 +873,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`);
@@ -1039,7 +1074,30 @@ const mcpController = ({ strapi }) => ({
         plugin.sessions.set(sessionId, session);
         strapi.log.debug(`[yt-transcript-mcp] New session created: ${sessionId} (auth: ${ctx.state.authMethod})`);
       }
-      await session.transport.handleRequest(ctx.req, ctx.res, ctx.request.body);
+      try {
+        await session.transport.handleRequest(ctx.req, ctx.res, ctx.request.body);
+      } catch (transportError) {
+        strapi.log.warn(`[yt-transcript-mcp] Transport error, cleaning up session: ${requestedSessionId}`, {
+          error: transportError instanceof Error ? transportError.message : String(transportError)
+        });
+        try {
+          session.server.close();
+        } catch {
+        }
+        plugin.sessions.delete(requestedSessionId);
+        if (!ctx.res.headersSent) {
+          ctx.status = 400;
+          ctx.body = {
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Session transport error. Please reinitialize the connection."
+            },
+            id: null
+          };
+        }
+        return;
+      }
       ctx.respond = false;
     } catch (error) {
       strapi.log.error("[yt-transcript-mcp] Error handling MCP request", {
@@ -1130,19 +1188,57 @@ function createProxyFetch(proxyUrl) {
     return void 0;
   }
   const proxyAgent = new undici.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 undici.fetch(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 urlString = input instanceof URL ? input.toString() : input;
-    return undici.fetch(urlString, { ...init, dispatcher: proxyAgent });
+    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 undici.fetch(url, options2);
+    if (!response.ok) {
+      console.log(`[yt-transcript] Proxy response: ${response.status} ${response.statusText}`);
+    }
+    return response;
   };
 }
 function decodeHtmlEntities(text) {
@@ -1220,34 +1316,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 youtubei_js.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,
@@ -1271,12 +1410,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,
@@ -1312,3 +1468,4 @@ const index = {
   middlewares
 };
 module.exports = index;
+//# sourceMappingURL=index.js.map