tekimax-ts 0.2.0 → 0.2.3

package/dist/index.cjs

@@ -32,13 +32,15 @@ var index_exports = {};
 __export(index_exports, {
   AnthropicProvider: () => AnthropicProvider,
   ApiTypes: () => types_exports,
-  ConvexManager: () => ConvexManager,
   FallbackProvider: () => FallbackProvider,
   GeminiProvider: () => GeminiProvider,
   GrokProvider: () => GrokProvider,
+  LoggerPlugin: () => LoggerPlugin,
+  MaxContextOverflowPlugin: () => MaxContextOverflowPlugin,
   OllamaProvider: () => OllamaProvider,
   OpenAIProvider: () => OpenAIProvider,
   OpenRouterProvider: () => OpenRouterProvider,
+  PIIFilterPlugin: () => PIIFilterPlugin,
   RateLimiter: () => RateLimiter,
   ResponseCache: () => ResponseCache,
   SessionStore: () => SessionStore,
@@ -1084,7 +1086,7 @@ var OpenAIProvider = class {
     this.name = "openai";
     this.client = new import_openai.default({
       apiKey: options.apiKey,
-      dangerouslyAllowBrowser: options.dangerouslyAllowBrowser
+      baseURL: options.baseURL
     });
   }
   async generateSpeech(options) {
@@ -1985,22 +1987,41 @@ function tool(def) {
 // src/core/generate.ts
 async function generateText({
   adapter,
+  plugins = [],
   ...options
 }) {
   const { model, tools, maxSteps = 1, temperature, maxTokens, signal } = options;
-  const currentMessages = [...options.messages];
+  let currentMessages = [...options.messages];
+  let currentModel = model;
   let steps = 0;
   const toolDefinitions = tools ? Object.values(tools) : void 0;
   while (steps < maxSteps) {
     steps++;
+    let context = {
+      model: currentModel,
+      messages: [...currentMessages],
+      timestamp: Date.now(),
+      requestOptions: { ...options }
+    };
+    for (const plugin of plugins) {
+      if (plugin.beforeRequest) {
+        const updated = await plugin.beforeRequest(context);
+        if (updated) context = updated;
+      }
+    }
+    currentMessages = context.messages;
+    currentModel = context.model;
     const result = await adapter.chat({
-      model,
+      model: currentModel,
       messages: currentMessages,
       tools: toolDefinitions,
       temperature,
       maxTokens,
       signal
     });
+    for (const plugin of plugins) {
+      if (plugin.afterResponse) await plugin.afterResponse(context, result);
+    }
     const { message } = result;
     currentMessages.push(message);
     if (!message.toolCalls || message.toolCalls.length === 0) {
@@ -2014,25 +2035,23 @@ async function generateText({
     }
     const toolResults = await Promise.all(
       message.toolCalls.map(async (call) => {
-        const tool2 = tools?.[call.function.name];
+        const toolName = call.function.name;
+        const tool2 = tools?.[toolName];
         if (!tool2) {
-          return {
-            id: call.id,
-            result: `Error: Tool ${call.function.name} not found`
-          };
+          return { id: call.id, result: `Error: Tool ${toolName} not found` };
         }
         try {
-          const args = JSON.parse(call.function.arguments);
+          let args = JSON.parse(call.function.arguments);
+          for (const plugin of plugins) {
+            if (plugin.beforeToolExecute) await plugin.beforeToolExecute(toolName, args);
+          }
           const output = await tool2.execute(args);
-          return {
-            id: call.id,
-            result: output
-          };
+          for (const plugin of plugins) {
+            if (plugin.afterToolExecute) await plugin.afterToolExecute(toolName, output);
+          }
+          return { id: call.id, result: output };
         } catch (error) {
-          return {
-            id: call.id,
-            result: `Error executing tool: ${error.message}`
-          };
+          return { id: call.id, result: `Error executing tool: ${error.message}` };
         }
       })
     );
@@ -2050,7 +2069,6 @@ async function generateText({
     toolCalls: [],
     toolResults: [],
     finishReason: "length",
-    // or 'tool_calls' if strictly ending on tools
     usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
     warnings: ["Max steps reached"]
   };
@@ -2306,69 +2324,80 @@ async function withRetry(fn, options = {}) {
   throw lastError || new Error("withRetry: unexpected exit");
 }
 function createRetryProvider(provider, options = {}) {
-  return {
-    ...provider,
-    name: provider.name,
-    chat: (chatOptions) => {
-      return withRetry(
-        () => provider.chat(chatOptions),
-        { ...options, signal: chatOptions.signal || options.signal }
-      );
-    },
-    chatStream: (chatOptions) => {
-      const iterable = {
-        [Symbol.asyncIterator]() {
-          let innerIterator = null;
-          return {
-            async next() {
-              if (!innerIterator) {
-                const stream = await withRetry(
-                  async () => provider.chatStream(chatOptions),
-                  { ...options, signal: chatOptions.signal || options.signal }
-                );
-                innerIterator = stream[Symbol.asyncIterator]();
-              }
-              return innerIterator.next();
-            },
-            async return() {
-              if (innerIterator?.return) {
-                return innerIterator.return();
+  return new Proxy(provider, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function" && typeof prop === "string") {
+        if (prop === "chatStream") {
+          return function(chatOptions) {
+            const iterable = {
+              [Symbol.asyncIterator]() {
+                let innerIterator = null;
+                return {
+                  async next() {
+                    if (!innerIterator) {
+                      const stream = await withRetry(
+                        async () => value.call(target, chatOptions),
+                        { ...options, signal: chatOptions.signal || options.signal }
+                      );
+                      innerIterator = stream[Symbol.asyncIterator]();
+                    }
+                    return innerIterator.next();
+                  },
+                  async return() {
+                    if (innerIterator?.return) {
+                      return innerIterator.return();
+                    }
+                    return { value: void 0, done: true };
+                  }
+                };
               }
-              return { value: void 0, done: true };
-            }
+            };
+            return iterable;
           };
         }
-      };
-      return iterable;
-    },
-    // Pass through multi-modal methods with retry
-    generateImage: provider.generateImage ? (opts) => withRetry(() => provider.generateImage(opts), options) : void 0,
-    editImage: provider.editImage ? (opts) => withRetry(() => provider.editImage(opts), options) : void 0,
-    analyzeImage: provider.analyzeImage ? (opts) => withRetry(() => provider.analyzeImage(opts), options) : void 0,
-    generateSpeech: provider.generateSpeech ? (opts) => withRetry(() => provider.generateSpeech(opts), options) : void 0,
-    transcribeAudio: provider.transcribeAudio ? (opts) => withRetry(() => provider.transcribeAudio(opts), options) : void 0,
-    generateVideo: provider.generateVideo ? (opts) => withRetry(() => provider.generateVideo(opts), options) : void 0,
-    analyzeVideo: provider.analyzeVideo ? (opts) => withRetry(() => provider.analyzeVideo(opts), options) : void 0
-  };
+        const promiseMethods = [
+          "chat",
+          "generateImage",
+          "editImage",
+          "analyzeImage",
+          "generateSpeech",
+          "transcribeAudio",
+          "generateVideo",
+          "analyzeVideo",
+          "embed"
+        ];
+        if (promiseMethods.includes(prop)) {
+          return function(...args) {
+            const callOpts = args[0] || {};
+            const sig = callOpts.signal || options.signal;
+            return withRetry(() => value.apply(target, args), { ...options, signal: sig });
+          };
+        }
+      }
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
 }
 
 // src/core/middleware.ts
 function wrapProvider(provider, middlewares) {
-  return {
-    ...provider,
-    name: provider.name,
-    chat: createWrappedChat(provider, middlewares),
-    chatStream: createWrappedChatStream(provider, middlewares),
-    // Multi-modal methods pass through unmodified.
-    // Middleware only applies to chat/chatStream for now.
-    generateImage: provider.generateImage?.bind(provider),
-    editImage: provider.editImage?.bind(provider),
-    analyzeImage: provider.analyzeImage?.bind(provider),
-    generateSpeech: provider.generateSpeech?.bind(provider),
-    transcribeAudio: provider.transcribeAudio?.bind(provider),
-    generateVideo: provider.generateVideo?.bind(provider),
-    analyzeVideo: provider.analyzeVideo?.bind(provider)
-  };
+  const wrappedChat = createWrappedChat(provider, middlewares);
+  const wrappedChatStream = createWrappedChatStream(provider, middlewares);
+  return new Proxy(provider, {
+    get(target, prop, receiver) {
+      if (prop === "chat") return wrappedChat;
+      if (prop === "chatStream") return wrappedChatStream;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
 }
 function createWrappedChat(provider, middlewares) {
   return async (options) => {
@@ -2517,35 +2546,35 @@ var FallbackProvider = class {
   }
   // --- Multi-modal: delegate to first provider that supports the capability ---
   get generateImage() {
-    const provider = this.providers.find((p) => p.generateImage);
+    const provider = this.providers.find((p) => typeof p.generateImage === "function");
     return provider?.generateImage?.bind(provider);
   }
   get editImage() {
-    const provider = this.providers.find((p) => p.editImage);
+    const provider = this.providers.find((p) => typeof p.editImage === "function");
     return provider?.editImage?.bind(provider);
   }
   get analyzeImage() {
-    const provider = this.providers.find((p) => p.analyzeImage);
+    const provider = this.providers.find((p) => typeof p.analyzeImage === "function");
     return provider?.analyzeImage?.bind(provider);
   }
   get generateSpeech() {
-    const provider = this.providers.find((p) => p.generateSpeech);
+    const provider = this.providers.find((p) => typeof p.generateSpeech === "function");
     return provider?.generateSpeech?.bind(provider);
   }
   get transcribeAudio() {
-    const provider = this.providers.find((p) => p.transcribeAudio);
+    const provider = this.providers.find((p) => typeof p.transcribeAudio === "function");
     return provider?.transcribeAudio?.bind(provider);
   }
   get generateVideo() {
-    const provider = this.providers.find((p) => p.generateVideo);
+    const provider = this.providers.find((p) => typeof p.generateVideo === "function");
     return provider?.generateVideo?.bind(provider);
   }
   get analyzeVideo() {
-    const provider = this.providers.find((p) => p.analyzeVideo);
+    const provider = this.providers.find((p) => typeof p.analyzeVideo === "function");
     return provider?.analyzeVideo?.bind(provider);
   }
   get embed() {
-    const provider = this.providers.find((p) => p.embed);
+    const provider = this.providers.find((p) => typeof p.embed === "function");
     return provider?.embed?.bind(provider);
   }
   /**
@@ -2572,174 +2601,7 @@ var FallbackProvider = class {
   }
 };
 
-// src/core/convex.ts
-var import_child_process = require("child_process");
-var MANAGEMENT_API = "https://api.convex.dev/v1";
-var ConvexManager = class {
-  constructor(options = {}) {
-    this.accessToken = options.accessToken || process.env.CONVEX_ACCESS_TOKEN || "";
-    this.teamId = options.teamId || process.env.CONVEX_TEAM_ID;
-    if (!this.accessToken) {
-      throw new Error(
-        "ConvexManager requires an access token. Pass accessToken in options or set CONVEX_ACCESS_TOKEN env var."
-      );
-    }
-  }
-  // ─── Project Lifecycle ──────────────────────────────────────────────
-  /**
-   * Create a new Convex project (includes an initial deployment).
-   */
-  async createProject(name, options = {}) {
-    const teamId = await this.resolveTeamId();
-    const body = {
-      projectName: name,
-      deploymentType: options.deploymentType || "prod"
-    };
-    if (options.region) {
-      body.deploymentRegion = options.region;
-    }
-    return this.request(
-      `${MANAGEMENT_API}/teams/${teamId}/create_project`,
-      { method: "POST", body }
-    );
-  }
-  /**
-   * List all projects for the team.
-   */
-  async listProjects() {
-    const teamId = await this.resolveTeamId();
-    return this.request(
-      `${MANAGEMENT_API}/teams/${teamId}/list_projects`
-    );
-  }
-  /**
-   * Delete a project by ID.
-   */
-  async deleteProject(projectId) {
-    await this.request(
-      `${MANAGEMENT_API}/projects/${projectId}`,
-      { method: "DELETE" }
-    );
-  }
-  // ─── Deployment Management ──────────────────────────────────────────
-  /**
-   * Generate a deploy key for a deployment (needed for schema push / deploy).
-   */
-  async createDeployKey(deploymentName) {
-    const result = await this.request(
-      `${MANAGEMENT_API}/deployments/${deploymentName}/create_deploy_key`,
-      { method: "POST", body: { name: "sdk-provisioned" } }
-    );
-    return result.deployKey;
-  }
-  /**
-   * Set environment variables on a deployment (bulk upsert).
-   */
-  async setEnvVars(deploymentName, vars) {
-    await this.request(
-      `https://${deploymentName}.convex.cloud/api/v1/update_environment_variables`,
-      {
-        method: "POST",
-        body: { changes: vars },
-        authStyle: "deploy"
-      }
-    );
-  }
-  /**
-   * List environment variables on a deployment.
-   */
-  async getEnvVars(deploymentName) {
-    return this.request(
-      `https://${deploymentName}.convex.cloud/api/v1/list_environment_variables`,
-      { authStyle: "deploy" }
-    );
-  }
-  /**
-   * Push Convex functions and schema to a deployment.
-   * Shells out to `npx convex deploy` with the given deploy key.
-   */
-  deploy(deployKey, options = {}) {
-    const cwd = options.projectDir || process.cwd();
-    const flags = options.flags?.join(" ") || "";
-    const cmd = `npx convex deploy --cmd-url-env-var-name CONVEX_URL ${flags}`.trim();
-    (0, import_child_process.execSync)(cmd, {
-      cwd,
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        CONVEX_DEPLOY_KEY: deployKey
-      }
-    });
-  }
-  // ─── Discovery ──────────────────────────────────────────────────────
-  /**
-   * Resolve token details (type, teamId, name) from the access token.
-   */
-  async getTokenDetails() {
-    return this.request(
-      `${MANAGEMENT_API}/token_details`
-    );
-  }
-  /**
-   * List available deployment regions.
-   */
-  async getRegions() {
-    const result = await this.request(
-      `${MANAGEMENT_API}/deployment_regions`
-    );
-    return result.items;
-  }
-  /**
-   * Generate an OpenAPI specification from a Convex deployment.
-   *
-   * Uses `npx convex-helpers open-api-spec` to introspect the deployment
-   * and produce a `convex-spec.yaml` file. You can then use tools like
-   * openapi-generator-cli to create type-safe clients in Go, Java, etc.
-   *
-   * @see https://docs.convex.dev/client/open-api
-   */
-  generateOpenAPISpec(options = {}) {
-    const cwd = options.projectDir || process.cwd();
-    const output = options.output || "convex-spec.yaml";
-    const extraFlags = options.flags?.join(" ") || "";
-    const cmd = `npx convex-helpers open-api-spec --output ${output} ${extraFlags}`.trim();
-    (0, import_child_process.execSync)(cmd, {
-      cwd,
-      stdio: "inherit"
-    });
-  }
-  // ─── Internal Helpers ───────────────────────────────────────────────
-  async resolveTeamId() {
-    if (this.teamId) return this.teamId;
-    const details = await this.getTokenDetails();
-    this.teamId = details.teamId;
-    return this.teamId;
-  }
-  async request(url, options = {}) {
-    const { method = "GET", body, authStyle = "bearer" } = options;
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: authStyle === "deploy" ? `Convex ${this.accessToken}` : `Bearer ${this.accessToken}`
-    };
-    const res = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
-    if (!res.ok) {
-      const text2 = await res.text().catch(() => "");
-      throw new Error(
-        `Convex API error (${res.status} ${res.statusText}): ${text2}`
-      );
-    }
-    const text = await res.text();
-    if (!text) return void 0;
-    return JSON.parse(text);
-  }
-};
-
 // src/core/cache.ts
-var import_crypto = require("crypto");
 var ResponseCache = class {
   constructor(redis, options = {}) {
     this.redis = redis;
@@ -2762,7 +2624,11 @@ var ResponseCache = class {
   }
   defaultKeyFn(model, messages) {
     const payload = JSON.stringify({ model, messages });
-    return (0, import_crypto.createHash)("sha256").update(payload).digest("hex");
+    let hash = 5381;
+    for (let i = 0; i < payload.length; i++) {
+      hash = (hash << 5) + hash + payload.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(16);
   }
 };
 var RateLimiter = class {
@@ -2859,28 +2725,55 @@ var SessionStore = class {
 
 // src/namespaces/text.ts
 var TextNamespace = class {
-  constructor(provider) {
+  constructor(provider, plugins = []) {
     this.provider = provider;
+    this.plugins = plugins;
+  }
+  async runBeforeRequest(options) {
+    let context = {
+      model: options.model,
+      messages: [...options.messages],
+      timestamp: Date.now(),
+      requestOptions: { ...options }
+    };
+    for (const plugin of this.plugins) {
+      if (plugin.beforeRequest) {
+        const updated = await plugin.beforeRequest(context);
+        if (updated) context = updated;
+      }
+    }
+    return context;
   }
   /**
    * Generate text from a prompt (Chat Completion).
    */
   async generate(options) {
-    return this.provider.chat(options);
+    const context = await this.runBeforeRequest(options);
+    const activeOptions = { ...options, messages: context.messages, model: context.model };
+    const result = await this.provider.chat(activeOptions);
+    for (const plugin of this.plugins) {
+      if (plugin.afterResponse) await plugin.afterResponse(context, result);
+    }
+    return result;
   }
   /**
    * Stream text generation.
    */
   async *generateStream(options) {
-    for await (const chunk of this.provider.chatStream(options)) {
+    const context = await this.runBeforeRequest(options);
+    const activeOptions = { ...options, messages: context.messages, model: context.model };
+    for await (const chunk of this.provider.chatStream(activeOptions)) {
+      for (const plugin of this.plugins) {
+        if (plugin.onStreamChunk) plugin.onStreamChunk(context, chunk);
+      }
       yield chunk;
     }
   }
   /**
-   * Generate embeddings for text input(s).
+   * Generate embeddings for text input(s). Only available if the provider supports embeddings.
    */
   async embed(options) {
-    if (!this.provider.embed) {
+    if (!("embed" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support embeddings`);
     }
     return this.provider.embed(options);
@@ -2902,28 +2795,28 @@ var ImagesNamespace = class {
     this.provider = provider;
   }
   /**
-   * Generate images from a prompt.
+   * Generate images from a prompt. Only available if the provider supports image generation.
    */
   async generate(options) {
-    if (!this.provider.generateImage) {
+    if (!("generateImage" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support image generation`);
     }
     return this.provider.generateImage(options);
   }
   /**
-   * Edit an image with a prompt.
+   * Edit an image with a prompt. Only available if the provider supports image editing.
    */
   async edit(options) {
-    if (!this.provider.editImage) {
+    if (!("editImage" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support image editing`);
     }
     return this.provider.editImage(options);
   }
   /**
-   * Analyze an image (Vision).
+   * Analyze an image (Vision). Only available if the provider supports vision analytics.
    */
   async analyze(options) {
-    if (!this.provider.analyzeImage) {
+    if (!("analyzeImage" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support image analysis`);
     }
     return this.provider.analyzeImage(options);
@@ -2936,19 +2829,19 @@ var AudioNamespace = class {
     this.provider = provider;
   }
   /**
-   * Convert text to speech.
+   * Convert text to speech. Only available if the provider supports TTS.
    */
   async speak(options) {
-    if (!this.provider.generateSpeech) {
+    if (!("generateSpeech" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support speech generation`);
     }
     return this.provider.generateSpeech(options);
   }
   /**
-   * Transcribe audio to text.
+   * Transcribe audio to text. Only available if the provider supports STT.
    */
   async transcribe(options) {
-    if (!this.provider.transcribeAudio) {
+    if (!("transcribeAudio" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support audio transcription`);
     }
     return this.provider.transcribeAudio(options);
@@ -2961,19 +2854,19 @@ var VideosNamespace = class {
     this.provider = provider;
   }
   /**
-   * Generate a video from a prompt.
+   * Generate a video from a prompt. Only available if the provider supports video generation.
    */
   async generate(options) {
-    if (!this.provider.generateVideo) {
+    if (!("generateVideo" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support video generation`);
     }
     return this.provider.generateVideo(options);
   }
   /**
-   * Analyze a video (Video-to-Text).
+   * Analyze a video (Video-to-Text). Only available if the provider supports video analysis.
    */
   async analyze(options) {
-    if (!this.provider.analyzeVideo) {
+    if (!("analyzeVideo" in this.provider)) {
       throw new Error(`Provider '${this.provider.name}' does not support video analysis`);
     }
     return this.provider.analyzeVideo(options);
@@ -2984,7 +2877,11 @@ var VideosNamespace = class {
 var Tekimax = class {
   constructor(options) {
     this.provider = options.provider;
-    this.text = new TextNamespace(this.provider);
+    this.plugins = options.plugins || [];
+    for (const plugin of this.plugins) {
+      if (plugin.onInit) plugin.onInit(this);
+    }
+    this.text = new TextNamespace(this.provider, this.plugins);
     this.images = new ImagesNamespace(this.provider);
     this.audio = new AudioNamespace(this.provider);
     this.videos = new VideosNamespace(this.provider);
@@ -2996,17 +2893,87 @@ var Tekimax = class {
     return this.text.chat;
   }
 };
+
+// src/plugins/logger.ts
+var LoggerPlugin = class {
+  constructor() {
+    this.name = "LoggerPlugin";
+  }
+  onInit() {
+    console.log("[LoggerPlugin] Tekimax SDK initialized with Logger Plugin active.");
+  }
+  async beforeRequest(context) {
+    console.log(`[LoggerPlugin] Sending request to model: ${context.model} (${context.messages.length} messages)`);
+  }
+  async afterResponse(context, result) {
+    console.log(`[LoggerPlugin] Received completion from ${context.model}. Usage:`, result.usage);
+  }
+  onStreamChunk(context, chunk) {
+    if (chunk.usage) {
+      console.log(`[LoggerPlugin] Stream completed. Final usage:`, chunk.usage);
+    }
+  }
+  async beforeToolExecute(toolName, args) {
+    console.log(`[LoggerPlugin] Executing tool '${toolName}' with args:`, args);
+  }
+  async afterToolExecute(toolName, result) {
+    console.log(`[LoggerPlugin] Tool '${toolName}' returned successfully.`);
+  }
+};
+
+// src/plugins/pii.ts
+var PIIFilterPlugin = class {
+  constructor() {
+    this.name = "PIIFilterPlugin";
+    this.patterns = {
+      email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+      ssn: /\b\d{3}-\d{2}-\d{4}\b/g
+    };
+  }
+  async beforeRequest(context) {
+    context.messages = context.messages.map((msg) => {
+      if (typeof msg.content === "string") {
+        let safeContent = msg.content;
+        safeContent = safeContent.replace(this.patterns.email, "[REDACTED EMAIL]");
+        safeContent = safeContent.replace(this.patterns.ssn, "[REDACTED SSN]");
+        return { ...msg, content: safeContent };
+      }
+      return msg;
+    });
+    return context;
+  }
+};
+
+// src/plugins/context.ts
+var MaxContextOverflowPlugin = class {
+  constructor(maxMessages = 20) {
+    this.maxMessages = maxMessages;
+    this.name = "MaxContextOverflowPlugin";
+  }
+  async beforeRequest(context) {
+    if (context.messages.length > this.maxMessages) {
+      const hasSystem = context.messages[0]?.role === "system";
+      const systemMsg = hasSystem ? context.messages[0] : null;
+      const recentMsgs = context.messages.slice(-(this.maxMessages - (hasSystem ? 1 : 0)));
+      context.messages = hasSystem && systemMsg ? [systemMsg, ...recentMsgs] : recentMsgs;
+      console.warn(`[MaxContextOverflowPlugin] Truncated chat history to ${this.maxMessages} messages to preserve context limits.`);
+    }
+    return context;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnthropicProvider,
   ApiTypes,
-  ConvexManager,
   FallbackProvider,
   GeminiProvider,
   GrokProvider,
+  LoggerPlugin,
+  MaxContextOverflowPlugin,
   OllamaProvider,
   OpenAIProvider,
   OpenRouterProvider,
+  PIIFilterPlugin,
   RateLimiter,
   ResponseCache,
   SessionStore,