npm - @elizaos/plugin-knowledge - Versions diffs - 1.5.15 → 1.6.1 - Mend

@elizaos/plugin-knowledge 1.5.15 → 1.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/.vite/manifest.json +1 -1
package/dist/assets/{index-DRqE0iU1.js → index-DcxhjPNa.js} +4 -4
package/dist/index.d.ts +22 -0
package/dist/index.html +1 -1
package/dist/index.js +234 -127
package/dist/index.js.map +1 -1
package/package.json +2 -2

package/dist/index.d.ts CHANGED Viewed

@@ -19,6 +19,11 @@ declare const ModelConfigSchema: z.ZodObject<{
     EMBEDDING_DIMENSION: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
     LOAD_DOCS_ON_STARTUP: z.ZodDefault<z.ZodBoolean>;
     CTX_KNOWLEDGE_ENABLED: z.ZodDefault<z.ZodBoolean>;
+    RATE_LIMIT_ENABLED: z.ZodDefault<z.ZodBoolean>;
+    MAX_CONCURRENT_REQUESTS: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    REQUESTS_PER_MINUTE: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    TOKENS_PER_MINUTE: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    BATCH_DELAY_MS: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
 }, "strip", z.ZodTypeAny, {
     TEXT_EMBEDDING_MODEL: string;
     MAX_INPUT_TOKENS: number;
@@ -26,6 +31,11 @@ declare const ModelConfigSchema: z.ZodObject<{
     EMBEDDING_DIMENSION: number;
     LOAD_DOCS_ON_STARTUP: boolean;
     CTX_KNOWLEDGE_ENABLED: boolean;
+    RATE_LIMIT_ENABLED: boolean;
+    MAX_CONCURRENT_REQUESTS: number;
+    REQUESTS_PER_MINUTE: number;
+    TOKENS_PER_MINUTE: number;
+    BATCH_DELAY_MS: number;
     EMBEDDING_PROVIDER?: "openai" | "google" | undefined;
     TEXT_PROVIDER?: "openai" | "google" | "anthropic" | "openrouter" | undefined;
     OPENAI_API_KEY?: string | undefined;
@@ -55,6 +65,11 @@ declare const ModelConfigSchema: z.ZodObject<{
     EMBEDDING_DIMENSION?: string | number | undefined;
     LOAD_DOCS_ON_STARTUP?: boolean | undefined;
     CTX_KNOWLEDGE_ENABLED?: boolean | undefined;
+    RATE_LIMIT_ENABLED?: boolean | undefined;
+    MAX_CONCURRENT_REQUESTS?: string | number | undefined;
+    REQUESTS_PER_MINUTE?: string | number | undefined;
+    TOKENS_PER_MINUTE?: string | number | undefined;
+    BATCH_DELAY_MS?: string | number | undefined;
 }>;
 type ModelConfig = z.infer<typeof ModelConfigSchema>;
 /**
@@ -65,6 +80,8 @@ interface ProviderRateLimits {
     requestsPerMinute: number;
     tokensPerMinute?: number;
     provider: string;
+    rateLimitEnabled: boolean;
+    batchDelayMs: number;
 }
 /**
  * Options for text generation overrides
@@ -149,6 +166,11 @@ interface KnowledgeConfig {
     EMBEDDING_PROVIDER?: string;
     TEXT_PROVIDER?: string;
     TEXT_EMBEDDING_MODEL?: string;
+    RATE_LIMIT_ENABLED?: boolean;
+    MAX_CONCURRENT_REQUESTS?: number;
+    REQUESTS_PER_MINUTE?: number;
+    TOKENS_PER_MINUTE?: number;
+    BATCH_DELAY_MS?: number;
 }
 interface LoadResult {
     successful: number;

package/dist/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Agent Plugin View</title>
-    <script type="module" crossorigin src="./assets/index-DRqE0iU1.js"></script>
+    <script type="module" crossorigin src="./assets/index-DcxhjPNa.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-CFqKS0Ch.css">
   </head>
   <body>

package/dist/index.js CHANGED Viewed

@@ -181,7 +181,20 @@ var ModelConfigSchema = z.object({
   // config setting
   LOAD_DOCS_ON_STARTUP: z.boolean().default(false),
   // Contextual Knowledge settings
-  CTX_KNOWLEDGE_ENABLED: z.boolean().default(false)
+  CTX_KNOWLEDGE_ENABLED: z.boolean().default(false),
+  // Rate limiting settings
+  // Set RATE_LIMIT_ENABLED=false to disable all rate limiting for fast uploads
+  // Useful when using APIs without rate limits (e.g., self-hosted models)
+  // High defaults optimized for Vercel gateway / high-throughput APIs
+  RATE_LIMIT_ENABLED: z.boolean().default(true),
+  // Maximum concurrent requests (default: 150, set higher for faster processing)
+  MAX_CONCURRENT_REQUESTS: z.string().or(z.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 150),
+  // Requests per minute limit (default: 300)
+  REQUESTS_PER_MINUTE: z.string().or(z.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 300),
+  // Tokens per minute limit (default: 750000)
+  TOKENS_PER_MINUTE: z.string().or(z.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 75e4),
+  // Delay between batches in milliseconds (default: 100, set to 0 for no delay)
+  BATCH_DELAY_MS: z.string().or(z.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 100)
 });
 var KnowledgeServiceType = {
   KNOWLEDGE: "knowledge"
@@ -243,7 +256,15 @@ function validateModelConfig(runtime) {
       MAX_OUTPUT_TOKENS: getSetting("MAX_OUTPUT_TOKENS", "4096"),
       EMBEDDING_DIMENSION: embeddingDimension,
       LOAD_DOCS_ON_STARTUP: parseBooleanEnv(getSetting("LOAD_DOCS_ON_STARTUP")),
-      CTX_KNOWLEDGE_ENABLED: ctxKnowledgeEnabled
+      CTX_KNOWLEDGE_ENABLED: ctxKnowledgeEnabled,
+      // Rate limiting settings - optimized for batch embeddings
+      // With batch embeddings, we send 100 texts in ONE API call
+      // 935 chunks / 100 = ~10 API calls instead of 935!
+      RATE_LIMIT_ENABLED: parseBooleanEnv(getSetting("RATE_LIMIT_ENABLED", "true")),
+      MAX_CONCURRENT_REQUESTS: getSetting("MAX_CONCURRENT_REQUESTS", "100"),
+      REQUESTS_PER_MINUTE: getSetting("REQUESTS_PER_MINUTE", "500"),
+      TOKENS_PER_MINUTE: getSetting("TOKENS_PER_MINUTE", "1000000"),
+      BATCH_DELAY_MS: getSetting("BATCH_DELAY_MS", "100")
     });
     validateConfigRequirements(config, assumePluginOpenAI);
     return config;
@@ -309,49 +330,36 @@ function validateConfigRequirements(config, assumePluginOpenAI) {
 }
 async function getProviderRateLimits(runtime) {
   const config = validateModelConfig(runtime);
-  const getSetting = (key, defaultValue) => {
-    if (runtime) {
-      return runtime.getSetting(key) || defaultValue;
-    }
-    return process.env[key] || defaultValue;
-  };
-  const maxConcurrentRequests = parseInt(getSetting("MAX_CONCURRENT_REQUESTS", "30"), 10);
-  const requestsPerMinute = parseInt(getSetting("REQUESTS_PER_MINUTE", "60"), 10);
-  const tokensPerMinute = parseInt(getSetting("TOKENS_PER_MINUTE", "150000"), 10);
+  const rateLimitEnabled = config.RATE_LIMIT_ENABLED;
+  const maxConcurrentRequests = config.MAX_CONCURRENT_REQUESTS;
+  const requestsPerMinute = config.REQUESTS_PER_MINUTE;
+  const tokensPerMinute = config.TOKENS_PER_MINUTE;
+  const batchDelayMs = config.BATCH_DELAY_MS;
   const primaryProvider = config.TEXT_PROVIDER || config.EMBEDDING_PROVIDER;
+  if (!rateLimitEnabled) {
+    logger.info(
+      `[Document Processor] Rate limiting DISABLED - unlimited throughput mode (concurrent: ${maxConcurrentRequests}, batch delay: ${batchDelayMs}ms)`
+    );
+    return {
+      maxConcurrentRequests,
+      requestsPerMinute: Number.MAX_SAFE_INTEGER,
+      tokensPerMinute: Number.MAX_SAFE_INTEGER,
+      provider: primaryProvider || "unlimited",
+      rateLimitEnabled: false,
+      batchDelayMs
+    };
+  }
   logger.debug(
-    `[Document Processor] Rate limiting for ${primaryProvider}: ${requestsPerMinute} RPM, ${tokensPerMinute} TPM, ${maxConcurrentRequests} concurrent`
+    `[Document Processor] Rate limiting for ${primaryProvider}: ${requestsPerMinute} RPM, ${tokensPerMinute} TPM, ${maxConcurrentRequests} concurrent, ${batchDelayMs}ms batch delay`
   );
-  switch (primaryProvider) {
-    case "anthropic":
-      return {
-        maxConcurrentRequests,
-        requestsPerMinute,
-        tokensPerMinute,
-        provider: "anthropic"
-      };
-    case "openai":
-      return {
-        maxConcurrentRequests,
-        requestsPerMinute: Math.min(requestsPerMinute, 3e3),
-        tokensPerMinute: Math.min(tokensPerMinute, 15e4),
-        provider: "openai"
-      };
-    case "google":
-      return {
-        maxConcurrentRequests,
-        requestsPerMinute: Math.min(requestsPerMinute, 60),
-        tokensPerMinute: Math.min(tokensPerMinute, 1e5),
-        provider: "google"
-      };
-    default:
-      return {
-        maxConcurrentRequests,
-        requestsPerMinute,
-        tokensPerMinute,
-        provider: primaryProvider || "unknown"
-      };
-  }
+  return {
+    maxConcurrentRequests,
+    requestsPerMinute,
+    tokensPerMinute,
+    provider: primaryProvider || "unknown",
+    rateLimitEnabled: true,
+    batchDelayMs
+  };
 }
 // src/ctx-embeddings.ts
@@ -1433,8 +1441,9 @@ function getCtxKnowledgeEnabled(runtime) {
   let source;
   let rawValue;
   if (runtime) {
-    rawValue = runtime.getSetting("CTX_KNOWLEDGE_ENABLED");
-    const cleanValue = rawValue?.toString().trim().toLowerCase();
+    const settingValue = runtime.getSetting("CTX_KNOWLEDGE_ENABLED");
+    rawValue = typeof settingValue === "string" ? settingValue : settingValue?.toString();
+    const cleanValue = rawValue?.trim().toLowerCase();
     result = cleanValue === "true";
     source = "runtime.getSetting()";
   } else {
@@ -1490,15 +1499,22 @@ async function processFragmentsSynchronously({
   }
   const docName = documentTitle || documentId.substring(0, 8);
   logger4.info(`[Document Processor] "${docName}": Split into ${chunks.length} chunks`);
-  const providerLimits = await getProviderRateLimits();
-  const CONCURRENCY_LIMIT = Math.min(30, providerLimits.maxConcurrentRequests || 30);
+  const providerLimits = await getProviderRateLimits(runtime);
+  const CONCURRENCY_LIMIT = providerLimits.maxConcurrentRequests || 30;
   const rateLimiter = createRateLimiter(
     providerLimits.requestsPerMinute || 60,
-    providerLimits.tokensPerMinute
-  );
-  logger4.debug(
-    `[Document Processor] Rate limits: ${providerLimits.requestsPerMinute} RPM, ${providerLimits.tokensPerMinute} TPM (${providerLimits.provider}, concurrency: ${CONCURRENCY_LIMIT})`
+    providerLimits.tokensPerMinute,
+    providerLimits.rateLimitEnabled
   );
+  if (!providerLimits.rateLimitEnabled) {
+    logger4.info(
+      `[Document Processor] UNLIMITED MODE: concurrency ${CONCURRENCY_LIMIT}, batch delay ${providerLimits.batchDelayMs}ms`
+    );
+  } else {
+    logger4.debug(
+      `[Document Processor] Rate limits: ${providerLimits.requestsPerMinute} RPM, ${providerLimits.tokensPerMinute} TPM (${providerLimits.provider}, concurrency: ${CONCURRENCY_LIMIT})`
+    );
+  }
   const { savedCount, failedCount } = await processAndSaveFragments({
     runtime,
     documentId,
@@ -1511,7 +1527,8 @@ async function processFragmentsSynchronously({
     worldId: worldId || agentId,
     concurrencyLimit: CONCURRENCY_LIMIT,
     rateLimiter,
-    documentTitle
+    documentTitle,
+    batchDelayMs: providerLimits.batchDelayMs
   });
   const successRate = (savedCount / chunks.length * 100).toFixed(1);
   if (failedCount > 0) {
@@ -1617,7 +1634,8 @@ async function processAndSaveFragments({
   worldId,
   concurrencyLimit,
   rateLimiter,
-  documentTitle
+  documentTitle,
+  batchDelayMs = 500
 }) {
   let savedCount = 0;
   let failedCount = 0;
@@ -1693,73 +1711,171 @@ async function processAndSaveFragments({
         failedChunks.push(originalChunkIndex);
       }
     }
-    if (i + concurrencyLimit < chunks.length) {
-      await new Promise((resolve2) => setTimeout(resolve2, 500));
+    if (i + concurrencyLimit < chunks.length && batchDelayMs > 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, batchDelayMs));
     }
   }
   return { savedCount, failedCount, failedChunks };
 }
+var EMBEDDING_BATCH_SIZE = 100;
 async function generateEmbeddingsForChunks(runtime, contextualizedChunks, rateLimiter) {
   const validChunks = contextualizedChunks.filter((chunk) => chunk.success);
   const failedChunks = contextualizedChunks.filter((chunk) => !chunk.success);
-  if (validChunks.length === 0) {
-    return failedChunks.map((chunk) => ({
+  const results = [];
+  for (const chunk of failedChunks) {
+    results.push({
       success: false,
       index: chunk.index,
       error: new Error("Chunk processing failed"),
       text: chunk.contextualizedText
-    }));
+    });
   }
-  return await Promise.all(
-    contextualizedChunks.map(async (contextualizedChunk) => {
-      if (!contextualizedChunk.success) {
-        return {
-          success: false,
-          index: contextualizedChunk.index,
-          error: new Error("Chunk processing failed"),
-          text: contextualizedChunk.contextualizedText
-        };
+  if (validChunks.length === 0) {
+    return results;
+  }
+  const useBatchEmbeddings = shouldUseBatchEmbeddings(runtime);
+  if (useBatchEmbeddings) {
+    logger4.info(`[Document Processor] Using BATCH embeddings for ${validChunks.length} chunks`);
+    return await generateEmbeddingsBatch(runtime, validChunks, rateLimiter, results);
+  } else {
+    logger4.info(`[Document Processor] Using individual embeddings for ${validChunks.length} chunks`);
+    return await generateEmbeddingsIndividual(runtime, validChunks, rateLimiter, results);
+  }
+}
+function shouldUseBatchEmbeddings(runtime) {
+  const setting = runtime.getSetting("BATCH_EMBEDDINGS") ?? process.env.BATCH_EMBEDDINGS;
+  if (setting === "false" || setting === false) {
+    return false;
+  }
+  return true;
+}
+async function generateEmbeddingsBatch(runtime, validChunks, rateLimiter, results) {
+  for (let batchStart = 0; batchStart < validChunks.length; batchStart += EMBEDDING_BATCH_SIZE) {
+    const batchEnd = Math.min(batchStart + EMBEDDING_BATCH_SIZE, validChunks.length);
+    const batch = validChunks.slice(batchStart, batchEnd);
+    const batchTexts = batch.map((c) => c.contextualizedText);
+    const totalTokens = batchTexts.reduce((sum, text) => sum + estimateTokens(text), 0);
+    await rateLimiter(totalTokens);
+    logger4.info(
+      `[Document Processor] Batch ${Math.floor(batchStart / EMBEDDING_BATCH_SIZE) + 1}/${Math.ceil(validChunks.length / EMBEDDING_BATCH_SIZE)}: ${batch.length} texts, ~${totalTokens} tokens`
+    );
+    try {
+      const embeddings = await generateBatchEmbeddingsViaRuntime(runtime, batchTexts);
+      for (let i = 0; i < batch.length; i++) {
+        const chunk = batch[i];
+        const embedding = embeddings[i];
+        if (embedding && embedding.length > 0 && embedding[0] !== 0) {
+          results.push({
+            embedding,
+            success: true,
+            index: chunk.index,
+            text: chunk.contextualizedText
+          });
+        } else {
+          results.push({
+            success: false,
+            index: chunk.index,
+            error: new Error("Empty or invalid embedding returned"),
+            text: chunk.contextualizedText
+          });
+        }
       }
-      const embeddingTokens = estimateTokens(contextualizedChunk.contextualizedText);
-      await rateLimiter(embeddingTokens);
-      try {
-        const generateEmbeddingOperation = async () => {
-          return await generateEmbeddingWithValidation(
-            runtime,
-            contextualizedChunk.contextualizedText
-          );
-        };
-        const { embedding, success, error } = await withRateLimitRetry(
-          generateEmbeddingOperation,
-          `embedding generation for chunk ${contextualizedChunk.index}`
-        );
-        if (!success) {
-          return {
+    } catch (error) {
+      logger4.error(`[Document Processor] Batch embedding error: ${error.message}`);
+      for (const chunk of batch) {
+        try {
+          const result = await generateEmbeddingWithValidation(runtime, chunk.contextualizedText);
+          if (result.success && result.embedding) {
+            results.push({
+              embedding: result.embedding,
+              success: true,
+              index: chunk.index,
+              text: chunk.contextualizedText
+            });
+          } else {
+            results.push({
+              success: false,
+              index: chunk.index,
+              error: result.error || new Error("Embedding failed"),
+              text: chunk.contextualizedText
+            });
+          }
+        } catch (fallbackError) {
+          results.push({
             success: false,
-            index: contextualizedChunk.index,
-            error,
-            text: contextualizedChunk.contextualizedText
-          };
+            index: chunk.index,
+            error: fallbackError,
+            text: chunk.contextualizedText
+          });
         }
-        return {
-          embedding,
-          success: true,
-          index: contextualizedChunk.index,
-          text: contextualizedChunk.contextualizedText
-        };
-      } catch (error) {
-        logger4.error(
-          `Error generating embedding for chunk ${contextualizedChunk.index}: ${error.message}`
-        );
-        return {
+      }
+    }
+  }
+  return results;
+}
+async function generateBatchEmbeddingsViaRuntime(runtime, texts) {
+  const batchResult = await runtime.useModel(
+    ModelType.TEXT_EMBEDDING,
+    { texts }
+    // Handler supports { texts: string[] } for batch mode
+  );
+  if (Array.isArray(batchResult) && Array.isArray(batchResult[0])) {
+    return batchResult;
+  }
+  if (Array.isArray(batchResult) && typeof batchResult[0] === "number") {
+    logger4.warn("[Document Processor] Runtime returned single embedding for batch request - falling back to individual calls");
+    const embeddings = await Promise.all(
+      texts.map(async (text) => {
+        const result = await runtime.useModel(ModelType.TEXT_EMBEDDING, { text });
+        if (Array.isArray(result)) {
+          return result;
+        }
+        return result?.embedding || [];
+      })
+    );
+    return embeddings;
+  }
+  logger4.error("[Document Processor] Unexpected batch result format:", typeof batchResult);
+  throw new Error("Unexpected batch embedding result format");
+}
+async function generateEmbeddingsIndividual(runtime, validChunks, rateLimiter, results) {
+  for (const chunk of validChunks) {
+    const embeddingTokens = estimateTokens(chunk.contextualizedText);
+    await rateLimiter(embeddingTokens);
+    try {
+      const generateEmbeddingOperation = async () => {
+        return await generateEmbeddingWithValidation(runtime, chunk.contextualizedText);
+      };
+      const { embedding, success, error } = await withRateLimitRetry(
+        generateEmbeddingOperation,
+        `embedding generation for chunk ${chunk.index}`
+      );
+      if (!success) {
+        results.push({
           success: false,
-          index: contextualizedChunk.index,
+          index: chunk.index,
           error,
-          text: contextualizedChunk.contextualizedText
-        };
+          text: chunk.contextualizedText
+        });
+      } else {
+        results.push({
+          embedding,
+          success: true,
+          index: chunk.index,
+          text: chunk.contextualizedText
+        });
       }
-    })
-  );
+    } catch (error) {
+      logger4.error(`Error generating embedding for chunk ${chunk.index}: ${error.message}`);
+      results.push({
+        success: false,
+        index: chunk.index,
+        error,
+        text: chunk.contextualizedText
+      });
+    }
+  }
+  return results;
 }
 async function getContextualizedChunks(runtime, fullDocumentText, chunks, contentType, batchOriginalIndices, documentTitle) {
   const ctxEnabled = getCtxKnowledgeEnabled(runtime);
@@ -1795,10 +1911,11 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
   if (!chunks || chunks.length === 0) {
     return [];
   }
-  const providerLimits = await getProviderRateLimits();
+  const providerLimits = await getProviderRateLimits(runtime);
   const rateLimiter = createRateLimiter(
     providerLimits.requestsPerMinute || 60,
-    providerLimits.tokensPerMinute
+    providerLimits.tokensPerMinute,
+    providerLimits.rateLimitEnabled
   );
   const config = validateModelConfig(runtime);
   const isUsingOpenRouter = config.TEXT_PROVIDER === "openrouter";
@@ -1839,9 +1956,11 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
             }
           } else {
             if (item.usesCaching) {
+              const combinedPrompt = item.systemPrompt ? `${item.systemPrompt}
+${item.promptText}` : item.promptText;
               return await runtime.useModel(ModelType.TEXT_LARGE, {
-                prompt: item.promptText,
-                system: item.systemPrompt
+                prompt: combinedPrompt
               });
             } else {
               return await runtime.useModel(ModelType.TEXT_LARGE, {
@@ -1945,17 +2064,11 @@ function prepareContextPrompts(chunks, fullDocumentText, contentType, batchIndic
 }
 async function generateEmbeddingWithValidation(runtime, text) {
   try {
-    const embeddingResult = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
-      text
-    });
+    const embeddingResult = await runtime.useModel(ModelType.TEXT_EMBEDDING, { text });
     const embedding = Array.isArray(embeddingResult) ? embeddingResult : embeddingResult?.embedding;
     if (!embedding || embedding.length === 0) {
-      logger4.warn(`Zero vector detected. Embedding result: ${JSON.stringify(embedding)}`);
-      return {
-        embedding: null,
-        success: false,
-        error: new Error("Zero vector detected")
-      };
+      logger4.warn(`Zero vector detected`);
+      return { embedding: null, success: false, error: new Error("Zero vector detected") };
     }
     return { embedding, success: true };
   } catch (error) {
@@ -1980,11 +2093,12 @@ async function withRateLimitRetry(operation, errorContext, retryDelay) {
     throw error;
   }
 }
-function createRateLimiter(requestsPerMinute, tokensPerMinute) {
+function createRateLimiter(requestsPerMinute, tokensPerMinute, rateLimitEnabled = true) {
   const requestTimes = [];
   const tokenUsage = [];
   const intervalMs = 60 * 1e3;
   return async function rateLimiter(estimatedTokens = 1e3) {
+    if (!rateLimitEnabled) return;
     const now = Date.now();
     while (requestTimes.length > 0 && now - requestTimes[0] > intervalMs) {
       requestTimes.shift();
@@ -1998,23 +2112,15 @@ function createRateLimiter(requestsPerMinute, tokensPerMinute) {
     if (requestLimitExceeded || tokenLimitExceeded) {
       let timeToWait = 0;
       if (requestLimitExceeded) {
-        const oldestRequest = requestTimes[0];
-        timeToWait = Math.max(timeToWait, oldestRequest + intervalMs - now);
+        timeToWait = Math.max(timeToWait, requestTimes[0] + intervalMs - now);
       }
       if (tokenLimitExceeded && tokenUsage.length > 0) {
-        const oldestTokenUsage = tokenUsage[0];
-        timeToWait = Math.max(timeToWait, oldestTokenUsage.timestamp + intervalMs - now);
+        timeToWait = Math.max(timeToWait, tokenUsage[0].timestamp + intervalMs - now);
       }
       if (timeToWait > 0) {
         const reason = requestLimitExceeded ? "request" : "token";
         if (timeToWait > 5e3) {
-          logger4.info(
-            `[Document Processor] Rate limiting: waiting ${Math.round(timeToWait / 1e3)}s due to ${reason} limit`
-          );
-        } else {
-          logger4.debug(
-            `[Document Processor] Rate limiting: ${timeToWait}ms wait (${reason} limit)`
-          );
+          logger4.info(`[Rate Limiter] Waiting ${Math.round(timeToWait / 1e3)}s (${reason} limit)`);
         }
         await new Promise((resolve2) => setTimeout(resolve2, timeToWait));
       }
@@ -2274,7 +2380,8 @@ var KnowledgeService = class _KnowledgeService extends Service {
     );
     try {
       await new Promise((resolve2) => setTimeout(resolve2, 1e3));
-      const knowledgePath = this.runtime.getSetting("KNOWLEDGE_PATH");
+      const knowledgePathSetting = this.runtime.getSetting("KNOWLEDGE_PATH");
+      const knowledgePath = typeof knowledgePathSetting === "string" ? knowledgePathSetting : void 0;
       const result = await loadDocsFromPath(
         this,
         this.runtime.agentId,