modality-kit 0.14.5 → 0.14.7

package/dist/index.js

@@ -16,6 +16,104 @@ 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,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          instructions,
+          meta,
+          ...restData
+        })
+      }
+    ]
+  };
+  if (Array.isArray(dataContent)) {
+    result.content.push(...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 +268,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 +290,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, {

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";

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/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.5",
+  "version": "0.14.7",
   "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"