yt-transcript-strapi-plugin 0.0.21 → 0.0.22

package/dist/server/index.mjs

@@ -3,14 +3,10 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprot
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { TokenTextSplitter } from "@langchain/textsplitters";
-import { PromptTemplate } from "@langchain/core/prompts";
-import { ChatOpenAI } from "@langchain/openai";
 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"),
-  generateReadable: z.boolean().optional().default(false)
+  videoId: z.string().min(1, "Video ID or URL is required")
 });
 const ListTranscriptsSchema = z.object({
   page: z.number().int().min(1).optional().default(1),
@@ -67,31 +63,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 {
@@ -121,14 +112,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: [
@@ -172,17 +155,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: [
@@ -219,14 +202,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 {
@@ -311,11 +294,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;
@@ -330,17 +312,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;
@@ -384,7 +365,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) {
@@ -392,13 +373,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 {
@@ -419,7 +400,7 @@ async function handleToolCall(strapi2, request) {
     };
   }
 }
-function createMcpServer(strapi2) {
+function createMcpServer(strapi) {
   const server = new Server(
     {
       name: "yt-transcript-mcp",
@@ -432,28 +413,28 @@ function createMcpServer(strapi2) {
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    strapi2.log.debug("[yt-transcript-mcp] Listing tools");
+    strapi.log.debug("[yt-transcript-mcp] Listing tools");
     return { tools };
   });
   server.setRequestHandler(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: {
@@ -512,9 +493,6 @@ const attributes = {
   },
   transcriptWithTimeCodes: {
     type: "json"
-  },
-  readableTranscript: {
-    type: "richtext"
   }
 };
 const schema = {
@@ -531,41 +509,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 = {
@@ -585,12 +556,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
@@ -670,18 +641,6 @@ const routes = {
     routes: [...admin]
   }
 };
-async function initializeModel({
-  openAIApiKey,
-  model,
-  temp
-}) {
-  return new 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;
 }
@@ -824,49 +783,14 @@ const fetchTranscript = async (videoId, options2) => {
     );
   }
 };
-async function processTextChunks(chunks, model) {
-  const punctuationPrompt = 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 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, {
@@ -879,20 +803,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 = {

package/dist/server/src/content-types/index.d.ts

@@ -32,9 +32,6 @@ declare const _default: {
                 transcriptWithTimeCodes: {
                     type: string;
                 };
-                readableTranscript: {
-                    type: string;
-                };
             };
         };
     };

package/dist/server/src/content-types/transcript/index.d.ts

@@ -31,9 +31,6 @@ declare const _default: {
             transcriptWithTimeCodes: {
                 type: string;
             };
-            readableTranscript: {
-                type: string;
-            };
         };
     };
 };

package/dist/server/src/index.d.ts

@@ -94,7 +94,6 @@ declare const _default: {
             }>;
             saveTranscript(payload: Record<string, unknown>): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
             findTranscript(videoId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
-            generateHumanReadableTranscript(transcript: string): Promise<string>;
         };
     };
     contentTypes: {
@@ -131,9 +130,6 @@ declare const _default: {
                     transcriptWithTimeCodes: {
                         type: string;
                     };
-                    readableTranscript: {
-                        type: string;
-                    };
                 };
             };
         };

package/dist/server/src/mcp/schemas/index.d.ts

@@ -1,13 +1,10 @@
 import { z } from 'zod';
 export declare const FetchTranscriptSchema: z.ZodObject<{
     videoId: z.ZodString;
-    generateReadable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     videoId?: string;
-    generateReadable?: boolean;
 }, {
     videoId?: string;
-    generateReadable?: boolean;
 }>;
 export declare const ListTranscriptsSchema: z.ZodObject<{
     page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -61,13 +58,10 @@ export type FindTranscriptsInput = z.infer<typeof FindTranscriptsSchema>;
 export declare const ToolSchemas: {
     readonly fetch_transcript: z.ZodObject<{
         videoId: z.ZodString;
-        generateReadable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
         videoId?: string;
-        generateReadable?: boolean;
     }, {
         videoId?: string;
-        generateReadable?: boolean;
     }>;
     readonly list_transcripts: z.ZodObject<{
         page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;

package/dist/server/src/mcp/tools/fetch-transcript.d.ts

@@ -9,11 +9,6 @@ export declare const fetchTranscriptTool: {
                 type: string;
                 description: string;
             };
-            generateReadable: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
         };
         required: string[];
     };

package/dist/server/src/mcp/tools/index.d.ts

@@ -1,5 +1,18 @@
 import type { Core } from '@strapi/strapi';
 export declare const tools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            videoId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
     name: string;
     description: string;
     inputSchema: {
@@ -23,19 +36,6 @@ export declare const tools: ({
         };
         required: any[];
     };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            videoId: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
 })[];
 /**
  * Handle a tool call by delegating to the appropriate handler

package/dist/server/src/services/index.d.ts

@@ -17,7 +17,6 @@ declare const _default: {
         }>;
         saveTranscript(payload: Record<string, unknown>): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
         findTranscript(videoId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
-        generateHumanReadableTranscript(transcript: string): Promise<string>;
     };
 };
 export default _default;

package/dist/server/src/services/service.d.ts

@@ -1,5 +1,4 @@
 import type { Core } from '@strapi/strapi';
-export declare function generateModifiedTranscript(rawTranscript: string): Promise<string>;
 declare const service: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {
@@ -18,6 +17,5 @@ declare const service: ({ strapi }: {
     }>;
     saveTranscript(payload: Record<string, unknown>): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
     findTranscript(videoId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
-    generateHumanReadableTranscript(transcript: string): Promise<string>;
 };
 export default service;

package/node_modules/express/node_modules/media-typer/HISTORY.md

@@ -0,0 +1,50 @@
+1.1.0 / 2019-04-24
+==================
+
+  * Add `test(string)` function
+
+1.0.2 / 2019-04-19
+==================
+
+  * Fix JSDoc comment for `parse` function
+
+1.0.1 / 2018-10-20
+==================
+
+  * Remove left over `parameters` property from class
+
+1.0.0 / 2018-10-20
+==================
+
+This major release brings the module back to it's RFC 6838 roots. If you want
+a module to parse the `Content-Type` or similar HTTP headers, use the
+`content-type` module instead.
+
+  * Drop support for Node.js below 0.8
+  * Remove parameter handling, which is outside RFC 6838 scope
+  * Remove `parse(req)` and `parse(res)` signatures
+  * perf: enable strict mode
+  * perf: use a class for object creation
+
+0.3.0 / 2014-09-07
+==================
+
+  * Support Node.js 0.6
+  * Throw error when parameter format invalid on parse
+
+0.2.0 / 2014-06-18
+==================
+
+  * Add `typer.format()` to format media types
+
+0.1.0 / 2014-06-17
+==================
+
+  * Accept `req` as argument to `parse`
+  * Accept `res` as argument to `parse`
+  * Parse media type with extra LWS between type and first parameter
+
+0.0.0 / 2014-06-13
+==================
+
+  * Initial implementation

package/node_modules/express/node_modules/media-typer/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2014-2017 Douglas Christopher Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.