alepha 0.19.1 → 0.19.3

package/src/core/{primitives → __tests__}/$pipeline.spec.ts

@@ -5,7 +5,7 @@ import {
   createMiddleware,
   type Middleware,
   PipelinePrimitive,
-} from "./$pipeline.ts";
+} from "../primitives/$pipeline.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // Test helpers — fake middleware factories

package/src/core/{primitives → __tests__}/$scope.spec.ts

@@ -4,8 +4,8 @@ import {
   $pipeline,
   type Middleware,
   type MiddlewareMetadata,
-} from "./$pipeline.ts";
-import { $scope } from "./$scope.ts";
+} from "../primitives/$pipeline.ts";
+import { $scope } from "../primitives/$scope.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $scope — core behavior

package/src/core/{providers → __tests__}/KeylessJsonSchemaCodec.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha, t } from "alepha";
 import { describe, test } from "vitest";
-import { KeylessJsonSchemaCodec } from "./KeylessJsonSchemaCodec.ts";
+import { KeylessJsonSchemaCodec } from "../providers/KeylessJsonSchemaCodec.ts";
 
 describe("KeylessJsonSchemaCodec", () => {
   describe("Basic types", () => {

package/src/core/{providers → __tests__}/SchemaValidator.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha, t } from "alepha";
 import { describe, test } from "vitest";
-import { SchemaValidator } from "./SchemaValidator.ts";
+import { SchemaValidator } from "../providers/SchemaValidator.ts";
 
 describe("SchemaValidator", () => {
   describe("Basic validation", () => {

package/src/core/{helpers → __tests__}/jsonSchemaToTypeBox.spec.ts

@@ -1,7 +1,7 @@
 import * as Value from "typebox/value";
 import { describe, test } from "vitest";
+import { jsonSchemaToTypeBox } from "../helpers/jsonSchemaToTypeBox.ts";
 import { t } from "../providers/TypeProvider.ts";
-import { jsonSchemaToTypeBox } from "./jsonSchemaToTypeBox.ts";
 
 describe("jsonSchemaToTypeBox", () => {
   describe("reserved/special property names", () => {

package/src/core/index.shared.ts

@@ -28,7 +28,7 @@ export * from "./primitives/$mode.ts";
 export * from "./primitives/$module.ts";
 export * from "./primitives/$pipeline.ts";
 export * from "./primitives/$scope.ts";
-export * from "./primitives/$use.ts";
+export * from "./primitives/$state.ts";
 export * from "./providers/AlsProvider.ts";
 export * from "./providers/CodecManager.ts";
 export * from "./providers/EventManager.ts";

package/src/core/primitives/{$use.ts → $state.ts}

@@ -1,7 +1,7 @@
 import type { State } from "../Alepha.ts";
 import { OPTIONS } from "../constants/OPTIONS.ts";
-import type { Static, TObject } from "../providers/TypeProvider.ts";
-import type { Atom } from "./$atom.ts";
+import type { Static } from "../providers/TypeProvider.ts";
+import type { Atom, TAtomObject } from "./$atom.ts";
 import { $context } from "./$context.ts";
 
 /**
@@ -18,7 +18,7 @@ import { $context } from "./$context.ts";
  * const userState = $atom({ schema: t.object({ name: t.text(), role: t.text() }) });
  *
  * class UserComponent {
- *   user = $use(userState); // Reactive reference to atom state
+ *   user = $state(userState); // Reactive reference to atom state
  *
  *   render() {
  *     return <div>Hello {this.user.name}!</div>;
@@ -26,7 +26,7 @@ import { $context } from "./$context.ts";
  * }
  * ```
  */
-export const $use = <T extends TObject, N extends string>(
+export const $state = <T extends TAtomObject, N extends string>(
   atom: Atom<T, N>,
 ): Readonly<Static<T>> => {
   const { alepha } = $context();

package/src/crypto/{providers → __tests__}/BrowserCryptoProvider.browser.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { BrowserCryptoProvider } from "./BrowserCryptoProvider.ts";
+import { BrowserCryptoProvider } from "../providers/BrowserCryptoProvider.ts";
 
 describe("BrowserCryptoProvider", () => {
   it("should throw on hashPassword", () => {

package/src/crypto/{providers → __tests__}/CryptoProvider.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { describe, expect, it } from "vitest";
-import { CryptoProvider } from "./CryptoProvider.ts";
+import { CryptoProvider } from "../providers/CryptoProvider.ts";
 
 describe("CryptoProvider", () => {
   it("should hash and verify a password", async () => {

package/src/datetime/{primitives → __tests__}/$debounce.spec.ts

@@ -1,6 +1,6 @@
 import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
-import { $debounce } from "./$debounce.ts";
+import { $debounce } from "../primitives/$debounce.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $debounce — core behavior

package/src/datetime/{primitives → __tests__}/$throttle.spec.ts

@@ -1,7 +1,7 @@
 import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
+import { $throttle } from "../primitives/$throttle.ts";
 import { DateTimeProvider } from "../providers/DateTimeProvider.ts";
-import { $throttle } from "./$throttle.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $throttle — core behavior

package/src/datetime/{primitives → __tests__}/$timeout.spec.ts

@@ -1,7 +1,7 @@
 import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
+import { $timeout } from "../primitives/$timeout.ts";
 import { DateTimeProvider } from "../providers/DateTimeProvider.ts";
-import { $timeout } from "./$timeout.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $timeout — core behavior

package/src/email/brevo/{providers → __tests__}/BrevoEmailProvider.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { BrevoEmailProvider } from "./BrevoEmailProvider.ts";
+import { BrevoEmailProvider } from "../providers/BrevoEmailProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/email/core/{providers → __tests__}/LocalEmailProvider.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/system";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { EmailError } from "../errors/EmailError.ts";
 import {
   LocalEmailProvider,
@@ -13,7 +13,7 @@ const DEFAULT_DIRECTORY = localEmailOptions.options.default.directory;
 
 describe("LocalEmailProvider", () => {
   describe("send", () => {
-    test("should successfully send email to local file", async () => {
+    it("should successfully send email to local file", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -35,10 +35,15 @@ describe("LocalEmailProvider", () => {
 
       expect(memoryFs.writeFileCalls).toHaveLength(1);
       expect(memoryFs.writeFileCalls[0].path).toContain("test@example.com");
-      expect(memoryFs.writeFileCalls[0].data).toContain(subject);
+
+      const written = JSON.parse(memoryFs.writeFileCalls[0].data as string);
+      expect(written.to).toBe(to);
+      expect(written.subject).toBe(subject);
+      expect(written.body).toBe(body);
+      expect(written.sentAt).toBeDefined();
     });
 
-    test("should create proper filename with sanitized email and timestamp", async () => {
+    it("should create proper filename with sanitized email and timestamp", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -65,13 +70,13 @@ describe("LocalEmailProvider", () => {
       expect(memoryFs.joinCalls).toHaveLength(1);
       expect(memoryFs.joinCalls[0]).toEqual([
         DEFAULT_DIRECTORY,
-        "user_test@example.com+2023-01-01T12-00-00-000Z.html",
+        "user_test@example.com,2023-01-01T12-00-00-000Z.eml.json",
       ]);
 
       vi.useRealTimers();
     });
 
-    test("should sanitize special characters in email address", async () => {
+    it("should sanitize special characters in email address", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -93,11 +98,11 @@ describe("LocalEmailProvider", () => {
 
       expect(memoryFs.joinCalls).toHaveLength(1);
       expect(memoryFs.joinCalls[0][1]).toMatch(
-        /user_script_@example\.com\+.+\.html/,
+        /user_script_@example\.com,.+\.eml\.json/,
       );
     });
 
-    test("should create proper HTML content", async () => {
+    it("should create proper JSON content", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -107,6 +112,9 @@ describe("LocalEmailProvider", () => {
       const memoryFs = alepha.inject(MemoryFileSystemProvider);
       await alepha.start();
 
+      const mockDate = new Date("2023-01-01T12:00:00.000Z");
+      vi.setSystemTime(mockDate);
+
       const to = "test@example.com";
       const subject = "Test <Subject>";
       const body = "<p>Test body with <strong>HTML</strong></p>";
@@ -117,18 +125,17 @@ describe("LocalEmailProvider", () => {
         body,
       });
 
-      const htmlContent = memoryFs.writeFileCalls[0].data;
+      const content = JSON.parse(memoryFs.writeFileCalls[0].data as string);
+
+      expect(content.to).toBe(to);
+      expect(content.subject).toBe(subject);
+      expect(content.body).toBe(body);
+      expect(content.sentAt).toBe("2023-01-01T12:00:00.000Z");
 
-      expect(htmlContent).toContain("<!DOCTYPE html>");
-      expect(htmlContent).toContain("Test &lt;Subject&gt;"); // escaped subject
-      expect(htmlContent).toContain("test@example.com");
-      expect(htmlContent).toContain(
-        "<p>Test body with <strong>HTML</strong></p>",
-      ); // body not escaped
-      expect(htmlContent).toContain("Sent:");
+      vi.useRealTimers();
     });
 
-    test("should throw EmailError when writeFile fails", async () => {
+    it("should throw EmailError when writeFile fails", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -161,7 +168,7 @@ describe("LocalEmailProvider", () => {
       ).rejects.toThrow("Failed to save email to local file: Disk full");
     });
 
-    test("should handle non-Error exceptions", async () => {
+    it("should handle non-Error exceptions", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -194,7 +201,7 @@ describe("LocalEmailProvider", () => {
       ).rejects.toThrow("Failed to save email to local file: String error");
     });
 
-    test("should handle multiple recipients", async () => {
+    it("should handle multiple recipients", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -216,150 +223,32 @@ describe("LocalEmailProvider", () => {
     });
   });
 
-  describe("createEmailHtml", () => {
-    let provider: LocalEmailProvider;
-
-    beforeEach(async () => {
+  describe("createEmailJson", () => {
+    it("should return structured email data with sentAt timestamp", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
       });
-      provider = alepha.inject(LocalEmailProvider);
+      const provider = alepha.inject(LocalEmailProvider);
       await alepha.start();
-    });
 
-    test("should create proper HTML structure", () => {
       const mockDate = new Date("2023-01-01T12:00:00.000Z");
       vi.setSystemTime(mockDate);
 
-      const to = "test@example.com";
-      const subject = "Test Subject";
-      const body = "<p>Test body</p>";
-
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
-      });
-
-      expect(html).toContain("<!DOCTYPE html>");
-      expect(html).toContain('<html lang="en">');
-      expect(html).toContain("<head>");
-      expect(html).toContain("<body>");
-      expect(html).toContain("Test Subject");
-      expect(html).toContain("test@example.com");
-      expect(html).toContain("<p>Test body</p>");
-      expect(html).toContain("2023-01-01T12:00:00.000Z");
-
-      vi.useRealTimers();
-    });
-
-    test("should escape HTML in subject and email address", () => {
-      const to = "test<script>@example.com";
-      const subject = "Test <Subject> & More";
-      const body = "<p>Test body</p>";
-
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
+      const result = provider.createEmailJson({
+        to: "test@example.com",
+        subject: "Test Subject",
+        body: "<p>Test body</p>",
       });
 
-      expect(html).toContain("test&lt;script&gt;@example.com");
-      expect(html).toContain("Test &lt;Subject&gt; &amp; More");
-      expect(html).not.toContain("test<script>@example.com");
-      expect(html).not.toContain("Test <Subject> & More");
-    });
-
-    test("should not escape HTML in body content", () => {
-      const to = "test@example.com";
-      const subject = "Test Subject";
-      const body = "<p>Test body with <strong>HTML</strong> & entities</p>";
-
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
+      expect(result).toEqual({
+        to: "test@example.com",
+        subject: "Test Subject",
+        body: "<p>Test body</p>",
+        sentAt: "2023-01-01T12:00:00.000Z",
       });
 
-      expect(html).toContain(
-        "<p>Test body with <strong>HTML</strong> & entities</p>",
-      );
-    });
-
-    test("should include CSS styles", () => {
-      const to = "test@example.com";
-      const subject = "Test Subject";
-      const body = "<p>Test body</p>";
-
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
-      });
-
-      expect(html).toContain("<style>");
-      expect(html).toContain("font-family: Arial, sans-serif");
-      expect(html).toContain(".email-header");
-      expect(html).toContain(".email-body");
-      expect(html).toContain(".meta");
-    });
-  });
-
-  describe("escapeHtml", () => {
-    let provider: LocalEmailProvider;
-
-    beforeEach(async () => {
-      const alepha = Alepha.create().with({
-        provide: FileSystemProvider,
-        use: MemoryFileSystemProvider,
-      });
-      provider = alepha.inject(LocalEmailProvider);
-      await alepha.start();
-    });
-
-    test("should escape ampersands", () => {
-      const result = provider.escapeHtml("Tom & Jerry");
-      expect(result).toBe("Tom &amp; Jerry");
-    });
-
-    test("should escape less than signs", () => {
-      const result = provider.escapeHtml("5 < 10");
-      expect(result).toBe("5 &lt; 10");
-    });
-
-    test("should escape greater than signs", () => {
-      const result = provider.escapeHtml("10 > 5");
-      expect(result).toBe("10 &gt; 5");
-    });
-
-    test("should escape double quotes", () => {
-      const result = provider.escapeHtml('Say "Hello"');
-      expect(result).toBe("Say &quot;Hello&quot;");
-    });
-
-    test("should escape single quotes", () => {
-      const result = provider.escapeHtml("Don't worry");
-      expect(result).toBe("Don&#39;t worry");
-    });
-
-    test("should escape multiple special characters", () => {
-      const result = provider.escapeHtml(
-        '<script>alert("Hello & goodbye")</script>',
-      );
-      expect(result).toBe(
-        "&lt;script&gt;alert(&quot;Hello &amp; goodbye&quot;)&lt;/script&gt;",
-      );
-    });
-
-    test("should handle empty string", () => {
-      const result = provider.escapeHtml("");
-      expect(result).toBe("");
-    });
-
-    test("should handle string with no special characters", () => {
-      const result = provider.escapeHtml("Hello World");
-      expect(result).toBe("Hello World");
+      vi.useRealTimers();
     });
   });
 });

package/src/email/core/providers/LocalEmailProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { FileSystemProvider } from "alepha/system";
 import { EmailError } from "../errors/EmailError.ts";
@@ -34,7 +34,7 @@ declare module "alepha" {
 export class LocalEmailProvider implements EmailProvider {
   protected readonly log = $logger();
   protected readonly fs = $inject(FileSystemProvider);
-  protected readonly options = $use(localEmailOptions);
+  protected readonly options = $state(localEmailOptions);
 
   protected get directory(): string {
     return this.options.directory;
@@ -69,22 +69,14 @@ export class LocalEmailProvider implements EmailProvider {
     });
 
     try {
-      // Create filename: emailcontact+date
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
       for (const recipient of Array.isArray(to) ? to : [to]) {
         const sanitizedEmail = recipient.replace(/[^a-zA-Z0-9@.-]/g, "_");
-        const filename = `${sanitizedEmail}+${timestamp}.html`;
+        const filename = `${sanitizedEmail},${timestamp}.eml.json`;
         const filepath = this.fs.join(this.directory, filename);
 
-        // Create HTML content
-        const htmlContent = this.createEmailHtml({
-          to: recipient,
-          subject,
-          body,
-        });
-
-        // Write to file
-        await this.fs.writeFile(filepath, htmlContent);
+        const content = this.createEmailJson({ to: recipient, subject, body });
+        await this.fs.writeFile(filepath, JSON.stringify(content, null, 2));
 
         this.log.info("Email saved to local file", { filepath, to, subject });
       }
@@ -95,46 +87,16 @@ export class LocalEmailProvider implements EmailProvider {
     }
   }
 
-  public createEmailHtml(options: {
+  public createEmailJson(options: {
     to: string;
     subject: string;
     body: string;
-  }): string {
-    const { to, subject, body } = options;
-    const timestamp = new Date().toISOString();
-
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${this.escapeHtml(subject)}</title>
-    <style>
-        body { font-family: Arial, sans-serif; margin: 20px; }
-        .email-header { background-color: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
-        .email-body { background-color: #ffffff; padding: 15px; border: 1px solid #ddd; border-radius: 5px; }
-        .meta { font-size: 12px; color: #666; margin-bottom: 10px; }
-    </style>
-</head>
-<body>
-    <div class="email-header">
-        <div class="meta">Sent: ${timestamp}</div>
-        <div class="meta">To: ${this.escapeHtml(to)}</div>
-        <h1>${this.escapeHtml(subject)}</h1>
-    </div>
-    <div class="email-body">
-        ${body}
-    </div>
-</body>
-</html>`;
-  }
-
-  public escapeHtml(text: string): string {
-    return text
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;")
-      .replace(/'/g, "&#39;");
+  }): { to: string; subject: string; body: string; sentAt: string } {
+    return {
+      to: options.to,
+      subject: options.subject,
+      body: options.body,
+      sentAt: new Date().toISOString(),
+    };
   }
 }

package/src/email/smtp/providers/NodemailerEmailProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $env, $hook, $use, type Static, t } from "alepha";
+import { $atom, $env, $hook, $state, type Static, t } from "alepha";
 import {
   EmailError,
   type EmailProvider,
@@ -127,7 +127,7 @@ declare module "alepha" {
 export class NodemailerEmailProvider implements EmailProvider {
   protected readonly env = $env(envSchema);
   protected readonly log = $logger();
-  protected readonly options = $use(nodemailerEmailOptions);
+  protected readonly options = $state(nodemailerEmailOptions);
   protected transporter: Transporter | null = null;
 
   protected get host(): string {

package/src/lock/core/{primitives → __tests__}/$lock.middleware.spec.ts

@@ -2,7 +2,7 @@ import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
 import { LockAcquireError } from "../errors/LockAcquireError.ts";
 import { AlephaLock } from "../index.ts";
-import { $lock } from "./$lock.ts";
+import { $lock } from "../primitives/$lock.ts";
 
 describe("$lock middleware", () => {
   test("executes handler when lock is available", async ({ expect }) => {

package/src/lock/core/primitives/$lock.ts

@@ -2,7 +2,7 @@ import {
   $atom,
   $context,
   $inject,
-  $use,
+  $state,
   AlephaError,
   type AsyncFn,
   createMiddleware,
@@ -391,7 +391,7 @@ export class LockPrimitive<TFunc extends AsyncFn> extends Primitive<
 > {
   protected readonly log = $logger();
   protected readonly provider = $inject(LockProvider);
-  protected readonly settings = $use(lockOptions);
+  protected readonly settings = $state(lockOptions);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
 
   /**

package/src/logger/index.ts

@@ -57,14 +57,19 @@ export const AlephaLogger = $module({
     const env = alepha.parseEnv(envSchema);
 
     // Support DEBUG env var (debug package convention) as shorthand for LOG_LEVEL/LOG_FORMAT.
+    // DEBUG=1 → LOG_LEVEL=trace LOG_FORMAT=pretty
     // DEBUG=alepha:* → LOG_LEVEL=alepha.*:debug,info LOG_FORMAT=pretty
     let logLevel = env.LOG_LEVEL;
     let logFormat = env.LOG_FORMAT;
     if (env.DEBUG) {
-      const patterns = env.DEBUG.split(",")
-        .map((p) => p.trim().replaceAll(":", "."))
-        .filter(Boolean);
-      logLevel ??= `${patterns.map((p) => `${p}:debug`).join(",")},info`;
+      if (env.DEBUG === "1" || env.DEBUG === "true") {
+        logLevel ??= "trace";
+      } else {
+        const patterns = env.DEBUG.split(",")
+          .map((p) => p.trim().replaceAll(":", "."))
+          .filter(Boolean);
+        logLevel ??= `${patterns.map((p) => `${p}:debug`).join(",")},info`;
+      }
       logFormat ??= "pretty";
     }
 
@@ -134,7 +139,12 @@ export const AlephaLogger = $module({
 
     alepha.store.set(
       "alepha.logger.level",
-      logLevel ?? (alepha.isTest() ? "trace" : "info"),
+      logLevel ??
+        (alepha.isTest()
+          ? "trace"
+          : alepha.isProduction() && alepha.isBrowser()
+            ? "warn"
+            : "info"),
     );
   },
 });
@@ -146,6 +156,7 @@ const envSchema = t.object({
    * Enable debug logging for specific modules using the `debug` package convention.
    *
    * @example
+   * DEBUG=1 # Shorthand for LOG_LEVEL=trace LOG_FORMAT=pretty
    * DEBUG=alepha:* # Enable debug logging for all alepha modules
    * DEBUG=alepha:orm:* # Enable debug logging for alepha.orm modules
    * DEBUG=* # Enable debug logging for all modules

package/src/mcp/transports/SseMcpTransport.ts

@@ -1,4 +1,4 @@
-import { $atom, $inject, $use, t } from "alepha";
+import { $atom, $inject, $state, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { $route } from "alepha/server";
 import {
@@ -60,7 +60,7 @@ export const mcpSseOptions = $atom({
  */
 export class SseMcpTransport {
   protected readonly log = $logger();
-  protected readonly options = $use(mcpSseOptions);
+  protected readonly options = $state(mcpSseOptions);
   protected readonly mcpServer = $inject(McpServerProvider);
 
   /**