modality-kit 0.14.4 → 0.14.6

package/dist/index.js

@@ -16,6 +16,100 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/ErrorCode.ts
+class ErrorCode extends Error {
+  cause;
+  constructor(message, originalError) {
+    super(message);
+    this.name = this.constructor.name;
+    if (originalError) {
+      this.cause = originalError;
+    }
+  }
+}
+
+// src/util_response.ts
+var ContentType = [
+  "text",
+  "image",
+  "audio",
+  "resource_link",
+  "resource"
+];
+function formatSuccessResponse(successData, meta) {
+  const data = structuredClone(successData);
+  const { instructions, content: dataContent, ...restData } = data;
+  const result = {
+    isError: false,
+    structuredContent: {
+      instructions,
+      meta,
+      ...restData
+    },
+    content: []
+  };
+  if (Array.isArray(dataContent)) {
+    result.content = dataContent.map((item) => {
+      if (typeof item === "string") {
+        return { type: "text", text: item };
+      } else if (item.type && ContentType.includes(item.type)) {
+        return item;
+      } else {
+        return { type: "text", text: JSON.stringify(item) };
+      }
+    });
+  }
+  return result;
+}
+function formatErrorResponse(errorData, operation, meta) {
+  let errorResponse;
+  let isError = true;
+  if (typeof errorData === "string") {
+    errorResponse = {
+      error: errorData,
+      operation,
+      meta
+    };
+  } else if (errorData instanceof ErrorCode) {
+    errorResponse = {
+      error: errorData.message,
+      operation,
+      meta,
+      code: errorData.code,
+      reason: errorData.cause?.message
+    };
+  } else if (errorData instanceof Error) {
+    errorResponse = {
+      error: errorData.message,
+      operation,
+      meta
+    };
+  } else if (typeof errorData === "object" && errorData !== null && typeof errorData.message === "string") {
+    const errObj = errorData;
+    isError = !errObj.success;
+    errorResponse = {
+      error: errObj.message,
+      code: errObj.code,
+      operation: errObj.operation || operation,
+      meta
+    };
+  } else {
+    errorResponse = {
+      error: "Unknown error",
+      operation,
+      meta
+    };
+  }
+  return {
+    isError,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(errorResponse)
+      }
+    ]
+  };
+}
 // src/util_logger.ts
 var levels = [null, "debug", "info", "warn", "error", "success"];
 
@@ -170,20 +264,8 @@ class ModalityLogger {
   }
 }
 var getLoggerInstance = ModalityLogger.getInstance.bind(ModalityLogger);
-
 // src/util_error.ts
 var logger = getLoggerInstance("Safe to Handle");
-
-class ErrorCode extends Error {
-  cause;
-  constructor(message, originalError) {
-    super(message);
-    this.name = this.constructor.name;
-    if (originalError) {
-      this.cause = originalError;
-    }
-  }
-}
 function withErrorHandling(fn, operation) {
   return async (...args) => {
     try {
@@ -204,68 +286,6 @@ function withErrorHandling(fn, operation) {
     }
   };
 }
-
-// src/util_response.ts
-function formatSuccessResponse(content, meta) {
-  let otherContent;
-  const instructions = content.instructions;
-  if (instructions != null) {
-    const { instructions: instructions2, ...restContent } = content;
-    otherContent = JSON.parse(JSON.stringify(restContent || {}));
-  } else {
-    otherContent = JSON.parse(JSON.stringify(content || {}));
-  }
-  return JSON.stringify({
-    success: true,
-    instructions,
-    content: Object.keys(otherContent || {}).length ? otherContent : undefined,
-    meta
-  });
-}
-function formatErrorResponse(errorData, operation, meta) {
-  let errorResponse;
-  if (typeof errorData === "string") {
-    errorResponse = {
-      success: false,
-      error: errorData,
-      operation,
-      meta
-    };
-  } else if (errorData instanceof ErrorCode) {
-    errorResponse = {
-      success: false,
-      error: errorData.message,
-      code: errorData.code,
-      reason: errorData.cause?.message,
-      operation,
-      meta
-    };
-  } else if (errorData instanceof Error) {
-    errorResponse = {
-      success: false,
-      error: errorData.message,
-      operation,
-      meta
-    };
-  } else if (typeof errorData === "object" && errorData !== null && typeof errorData.message === "string") {
-    const errObj = errorData;
-    errorResponse = {
-      success: errObj.success || false,
-      error: errObj.message,
-      code: errObj.code,
-      operation: errObj.operation || operation,
-      meta
-    };
-  } else {
-    errorResponse = {
-      success: false,
-      error: "Unknown error",
-      operation,
-      meta
-    };
-  }
-  return JSON.stringify(errorResponse);
-}
 // src/schemas/schemas_symbol.ts
 var exports_schemas_symbol = {};
 __export(exports_schemas_symbol, {
@@ -5947,6 +5967,48 @@ class LruCache {
     return [...this._values.keys()];
   }
 }
+// src/simple-cache.ts
+class SimpleCache {
+  lruCache;
+  ttlMs;
+  maxSize;
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs ?? 300000;
+    this.maxSize = options.maxSize ?? 100;
+    this.lruCache = new LruCache(this.maxSize);
+  }
+  set(key, data, ttlMs) {
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      ttl: ttlMs ?? this.ttlMs
+    };
+    this.lruCache.set(key, entry);
+  }
+  get(key, ignoreTTL) {
+    const entry = this.lruCache.get(key);
+    if (!entry)
+      return null;
+    if (entry.ttl !== undefined && !ignoreTTL) {
+      const age = Date.now() - entry.timestamp;
+      if (age > entry.ttl) {
+        this.lruCache.delete(key);
+        return null;
+      }
+    }
+    return entry.data;
+  }
+  has(key) {
+    return this.lruCache.has(key);
+  }
+  delete(key) {
+    const existed = this.lruCache.delete(key);
+    return existed;
+  }
+  keys() {
+    return this.lruCache.keys();
+  }
+}
 export {
   withErrorHandling,
   loadVersion,
@@ -5959,6 +6021,7 @@ export {
   compressWithLanguageDetection as compressText,
   WebSocketClient,
   exports_schemas_symbol as SymbolTypes,
+  SimpleCache,
   LruCache,
   JSONRPCUtils,
   JSONRPCManager,

package/dist/types/ErrorCode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Base class for task-related errors
+ */
+export declare abstract class ErrorCode extends Error {
+    abstract readonly code: string | number;
+    cause?: Error;
+    constructor(message: string, originalError?: unknown);
+}

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 export { formatErrorResponse, formatSuccessResponse } from "./util_response";
 export { getLoggerInstance, type ModalityLogger } from "./util_logger";
-export { withErrorHandling, ErrorCode } from "./util_error";
+export { withErrorHandling } from "./util_error";
+export { ErrorCode } from "./ErrorCode";
 export * as SymbolTypes from "./schemas/schemas_symbol";
 export type { EmptyType } from "./schemas/schemas_empty";
 export { emptySchema } from "./schemas/schemas_empty";
@@ -23,3 +24,5 @@ export { ERROR_METHOD_NOT_FOUND } from "./jsonrpc-manager";
 export { isTestEnvironment } from "./util_tests/isTestEnvironment";
 export { WebSocketClient } from "./websocket-client";
 export { LruCache } from "./lruCache";
+export { SimpleCache } from "./simple-cache";
+export type { SimpleCacheOptions } from "./simple-cache";

package/dist/types/jsonrpc-manager.d.ts

@@ -4,7 +4,7 @@
  * Clean JSON-RPC 2.0 implementation for communication.
  * Provides method registration, routing, and lifecycle management.
  */
-import { ErrorCode } from "./util_error";
+import { ErrorCode } from "./ErrorCode";
 import { JSONRPCCall } from "./util_pending";
 import { JSONRPCErrorCode } from "./schemas/jsonrpc";
 import type { JSONRPCRequest, JSONRPCMessage, JSONRPCError, JSONRPCParams } from "./schemas/jsonrpc";

package/dist/types/schemas/schemas_symbol.d.ts

@@ -91,12 +91,12 @@ declare const fileEntrySchema: z.ZodObject<{
     type: z.ZodEnum<["file", "directory"]>;
     lastModified: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
-    path: string;
     type: "file" | "directory";
+    path: string;
     lastModified?: number | null | undefined;
 }, {
-    path: string;
     type: "file" | "directory";
+    path: string;
     lastModified?: number | null | undefined;
 }>;
 export type FileEntryType = z.infer<typeof fileEntrySchema>;

package/dist/types/simple-cache.d.ts

@@ -0,0 +1,48 @@
+/**
+ * SimpleCache - Unified caching utility with TTL and LRU support
+ *
+ * Supports two caching strategies:
+ * - TTL-based: Entries expire after specified time
+ * - LRU: Least Recently Used eviction when size limit reached
+ * - Hybrid: Both TTL and LRU can be enabled together
+ */
+/**
+ * Cache options
+ */
+export interface SimpleCacheOptions {
+    /** TTL in milliseconds. Set to undefined to disable TTL. Default: 300000 (5 minutes) */
+    ttlMs?: number;
+    /** Enable LRU eviction. Default: false */
+    enableLru?: boolean;
+    /** Max cache size for LRU. Default: 100 */
+    maxSize?: number;
+}
+/**
+ * SimpleCache - Generic cache supporting TTL and/or LRU eviction
+ */
+export declare class SimpleCache<T> {
+    private lruCache;
+    private readonly ttlMs;
+    private readonly maxSize;
+    constructor(options?: SimpleCacheOptions);
+    /**
+     * Set cache entry
+     * @param key Cache key
+     * @param data Data to cache
+     * @param ttlMs Optional override for TTL (if undefined, uses instance TTL)
+     */
+    set(key: string, data: T, ttlMs?: number): void;
+    /**
+     * Get cache entry if still valid (not expired and not evicted by LRU)
+     */
+    get(key: string, ignoreTTL?: boolean): T | null;
+    /**
+     * Check if key exists and is valid
+     */
+    has(key: string): boolean;
+    /**
+     * Delete a specific key
+     */
+    delete(key: string): boolean;
+    keys(): string[];
+}

package/dist/types/util_error.d.ts

@@ -1,11 +1,3 @@
-/**
- * Base class for task-related errors
- */
-export declare abstract class ErrorCode extends Error {
-    abstract readonly code: string | number;
-    cause?: Error;
-    constructor(message: string, originalError?: unknown);
-}
 /**
  * Wrapper for any functions that adds consistent error handling
  */

package/dist/types/util_response.d.ts

@@ -1,16 +1,11 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 /**
  * Utility functions for formatting MCP responses
  *
  * This is a global utility module that should not import domain-specific classes.
  * It provides generic response formatting for any MCP tool.
  */
-export interface McpSuccessResponse {
-    success: true;
-    content: any;
-    meta?: any;
-}
 export interface McpErrorResponse {
-    success: boolean;
     code?: string | number;
     error: string;
     operation?: string;
@@ -30,12 +25,9 @@ interface ErrorData extends Record<string, any> {
     message: string;
     operation?: string;
 }
-/**
- * Format a successful response for MCP tools
- */
-export declare function formatSuccessResponse(content: SuccessData, meta?: any): string;
+export declare function formatSuccessResponse(successData: SuccessData, meta?: any): CallToolResult;
 /**
  * Format an error response for MCP tools using generic error data
  */
-export declare function formatErrorResponse(errorData: ErrorData | Error | string | unknown, operation?: string, meta?: Record<string, any>): string;
+export declare function formatErrorResponse(errorData: ErrorData | Error | string | unknown, operation?: string, meta?: Record<string, any>): CallToolResult;
 export {};

package/dist/types/util_text_compression.d.ts

@@ -1,5 +1,5 @@
 import { ModalityLogger } from './util_logger.js';
-import { ErrorCode } from './util_error.js';
+import { ErrorCode } from './ErrorCode';
 export interface CompressionConfig {
     maxTokens: number;
     compressionLevel: "light" | "moderate" | "aggressive";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.14.4",
+  "version": "0.14.6",
   "name": "modality-kit",
   "repository": {
     "type": "git",
@@ -11,6 +11,7 @@
   "author": "Hill <hill@kimo.com>",
   "license": "ISC",
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.2",
     "@types/bun": "^1.2.23",
     "typescript": "^5.9.2",
     "zod": "^3.25.76"