tekimax-ts 0.2.0 → 0.2.1

package/README.md

@@ -18,7 +18,7 @@ npm install tekimax-ts
 ## 🌟 Features
 
 - **Universal API**: One interface for all providers. Switch from OpenAI to Ollama with a single config change.
-- **Type Safety**: End-to-end TypeScript support. Zod schemas for runtime validation.
+- **Strict Modality Type Safety**: End-to-end TypeScript support. Strong capability interfaces ensure compile-time safety (e.g., your code won't compile if you call `.images.generate()` on a provider missing the `ImageGenerationCapability`). Zod schemas for runtime validation.
 - **Zero Latency**: Lightweight adapter pattern with zero runtime overhead.
 - **Zero CVEs**: Hardened supply chain using Chainguard images.
 - **Redis Adapter** _(optional)_: Response caching, rate limiting, token budgets, and session storage with any Redis client.
@@ -53,6 +53,60 @@ const claude = new Tekimax({
 const local = new Tekimax({
     provider: new OllamaProvider({ baseUrl: 'http://localhost:11434' })
 })
+
+// Custom Model Proxies (e.g. Internal API gateways)
+const proxyClient = new Tekimax({
+    provider: new OpenAIProvider({ 
+        apiKey: process.env.CUSTOM_PROXY_KEY,
+        baseURL: 'https://api.my-custom-proxy.internal/v1' 
+    })
+})
+
+### Streaming
+
+Tekimax-TS uses standard Javascript Async Iterables for real-time streaming:
+
+```typescript
+const stream = await client.text.generateStream({
+  model: "gpt-4o",
+  messages: [{ role: "user", content: "Tell me a story" }]
+})
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.delta)
+}
+```
+
+## 🔌 Plugin Architecture (Lifecycle Hooks)
+
+The SDK provides a robust middleware architecture via `plugins`. You can snap in pre-built plugins for Security, Scalability, and Telemetry, or build your own.
+
+```typescript
+import { Tekimax, OpenAIProvider, PIIFilterPlugin, LoggerPlugin, MaxContextOverflowPlugin } from 'tekimax-ts'
+
+const client = new Tekimax({
+    provider: new OpenAIProvider({ apiKey: 'sk-...' }),
+    plugins: [
+        new LoggerPlugin(), // Telemetry
+        new PIIFilterPlugin(), // Security: Redacts emails and SSNs
+        new MaxContextOverflowPlugin(15) // Scalability: Prevents context bloat in long loops
+    ]
+})
+```
+
+### Building Custom Plugins
+Implement the `TekimaxPlugin` interface to hook into the request/response lifecycle:
+
+```typescript
+export interface TekimaxPlugin {
+    name: string
+    onInit?: (client: Tekimax) => void
+    beforeRequest?: (context: PluginContext) => Promise<void | PluginContext>
+    afterResponse?: (context: PluginContext, result: ChatResult) => Promise<void>
+    onStreamChunk?: (context: PluginContext, chunk: StreamChunk) => void
+    beforeToolExecute?: (toolName: string, args: unknown) => Promise<void>
+    afterToolExecute?: (toolName: string, result: unknown) => Promise<void>
+}
 ```
 
 ### 2. Multi-Modal Interfaces

package/dist/index.cjs

@@ -36,9 +36,12 @@ __export(index_exports, {
   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 +1087,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 +1988,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 +2036,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 +2070,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 +2325,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 +2547,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);
   }
   /**
@@ -2573,7 +2603,6 @@ 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 = {}) {
@@ -2656,20 +2685,17 @@ var ConvexManager = class {
   }
   /**
    * Push Convex functions and schema to a deployment.
-   * Shells out to `npx convex deploy` with the given deploy key.
+   * Use the Convex CLI directly to run this command.
    */
   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
-      }
-    });
+    const cmd = `CONVEX_DEPLOY_KEY=${deployKey} npx convex deploy --cmd-url-env-var-name CONVEX_URL ${flags}`.trim();
+    throw new Error(
+      `Deploys must be executed via the CLI. Run the following command in your terminal from ${cwd}:
+
+  ${cmd}`
+    );
   }
   // ─── Discovery ──────────────────────────────────────────────────────
   /**
@@ -2691,10 +2717,7 @@ var ConvexManager = class {
   }
   /**
    * 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.
+   * Use the Convex CLI directly to run this command.
    *
    * @see https://docs.convex.dev/client/open-api
    */
@@ -2703,10 +2726,11 @@ var ConvexManager = class {
     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"
-    });
+    throw new Error(
+      `OpenAPI generation must be executed via the CLI. Run the following command in your terminal from ${cwd}:
+
+  ${cmd}`
+    );
   }
   // ─── Internal Helpers ───────────────────────────────────────────────
   async resolveTeamId() {
@@ -2739,7 +2763,6 @@ var ConvexManager = class {
 };
 
 // src/core/cache.ts
-var import_crypto = require("crypto");
 var ResponseCache = class {
   constructor(redis, options = {}) {
     this.redis = redis;
@@ -2762,7 +2785,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 +2886,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 +2956,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 +2990,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 +3015,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 +3038,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,6 +3054,70 @@ var Tekimax = class {
     return this.text.chat;
   }
 };
+
+// src/plugins/index.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;
+  }
+};
+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;
+  }
+};
+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.`);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnthropicProvider,
@@ -3004,9 +3126,12 @@ var Tekimax = class {
   FallbackProvider,
   GeminiProvider,
   GrokProvider,
+  LoggerPlugin,
+  MaxContextOverflowPlugin,
   OllamaProvider,
   OpenAIProvider,
   OpenRouterProvider,
+  PIIFilterPlugin,
   RateLimiter,
   ResponseCache,
   SessionStore,