@defai.digital/contracts 13.0.3

package/dist/mcp/v1/runtime/limits.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+// ============================================================================
+// Request Limits Configuration
+// ============================================================================
+export const MCPRequestLimitsSchema = z.object({
+    /** Maximum array size in requests */
+    maxArraySize: z.number().int().positive().default(100),
+    /** Maximum string length in requests */
+    maxStringLength: z.number().int().positive().default(100_000),
+    /** Maximum object depth */
+    maxObjectDepth: z.number().int().positive().default(10),
+    /** Maximum total request size in bytes */
+    maxRequestBytes: z.number().int().positive().default(10_485_760), // 10MB
+    /** Per-tool array limits (tool name -> max array size) */
+    toolArrayLimits: z
+        .record(z.string(), z.number().int().positive())
+        .default({
+        review_analyze: 100,
+        memory_bulk_delete: 1000,
+        ability_inject: 20,
+    }),
+});
+// ============================================================================
+// Validation Error
+// ============================================================================
+export const ValidationErrorSchema = z.object({
+    /** JSON path to the invalid field */
+    path: z.string(),
+    /** Error code */
+    code: z.enum([
+        'ARRAY_TOO_LARGE',
+        'STRING_TOO_LONG',
+        'OBJECT_TOO_DEEP',
+        'REQUEST_TOO_LARGE',
+        'INVALID_TYPE',
+        'REQUIRED_FIELD',
+    ]),
+    /** Human-readable message */
+    message: z.string(),
+    /** The limit that was exceeded */
+    limit: z.number().optional(),
+    /** The actual value */
+    actual: z.number().optional(),
+});
+// ============================================================================
+// Validation Result
+// ============================================================================
+export const ValidationResultSchema = z.discriminatedUnion('valid', [
+    z.object({
+        valid: z.literal(true),
+    }),
+    z.object({
+        valid: z.literal(false),
+        errors: z.array(ValidationErrorSchema).min(1),
+    }),
+]);
+// ============================================================================
+// Default Request Limits
+// ============================================================================
+export const DEFAULT_REQUEST_LIMITS = {
+    maxArraySize: 100,
+    maxStringLength: 100_000,
+    maxObjectDepth: 10,
+    maxRequestBytes: 10_485_760, // 10MB
+    toolArrayLimits: {
+        review_analyze: 100,
+        memory_bulk_delete: 1000,
+        ability_inject: 20,
+    },
+};
+// ============================================================================
+// Array Field Paths by Tool
+// ============================================================================
+/**
+ * Maps tool names to array field paths that need size validation
+ */
+export const TOOL_ARRAY_FIELDS = {
+    review_analyze: ['paths', 'excludePatterns'],
+    memory_bulk_delete: ['keys'],
+    ability_inject: ['coreAbilities', 'tags'],
+    guard_check: ['changedPaths'],
+};
+/**
+ * Get the array size limit for a specific tool and field
+ */
+export function getArrayLimit(toolName, _fieldPath, limits) {
+    // Check tool-specific limit first
+    const toolLimit = limits.toolArrayLimits[toolName];
+    if (toolLimit !== undefined) {
+        return toolLimit;
+    }
+    // Fall back to global limit
+    return limits.maxArraySize;
+}
+//# sourceMappingURL=limits.js.map

package/dist/mcp/v1/runtime/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","sourceRoot":"","sources":["../../../../src/mcp/v1/runtime/limits.ts"],"names":[],"mappings":"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"}

package/dist/mcp/v1/runtime/response.d.ts

@@ -0,0 +1,467 @@
+import { z } from 'zod';
+export declare const MCPErrorCodeSchema: z.ZodEnum<["INVALID_INPUT", "MISSING_REQUIRED_FIELD", "INVALID_FORMAT", "ARRAY_TOO_LARGE", "STRING_TOO_LONG", "REQUEST_TOO_LARGE", "NOT_FOUND", "ALREADY_EXISTS", "CONFLICT", "OPERATION_FAILED", "TOOL_TIMEOUT", "RATE_LIMITED", "MEMORY_PRESSURE", "INTERNAL_ERROR", "NOT_IMPLEMENTED", "SERVICE_UNAVAILABLE"]>;
+export type MCPErrorCode = z.infer<typeof MCPErrorCodeSchema>;
+export declare const RETRYABLE_ERRORS: Set<"INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE">;
+export declare function isRetryableError(code: MCPErrorCode): boolean;
+export declare const MCPStructuredErrorSchema: z.ZodObject<{
+    /** Error code for programmatic handling */
+    code: z.ZodEnum<["INVALID_INPUT", "MISSING_REQUIRED_FIELD", "INVALID_FORMAT", "ARRAY_TOO_LARGE", "STRING_TOO_LONG", "REQUEST_TOO_LARGE", "NOT_FOUND", "ALREADY_EXISTS", "CONFLICT", "OPERATION_FAILED", "TOOL_TIMEOUT", "RATE_LIMITED", "MEMORY_PRESSURE", "INTERNAL_ERROR", "NOT_IMPLEMENTED", "SERVICE_UNAVAILABLE"]>;
+    /** Human-readable message */
+    message: z.ZodString;
+    /** Additional context */
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Whether the operation can be retried */
+    retryable: z.ZodDefault<z.ZodBoolean>;
+    /** Suggested retry delay in ms (if retryable) */
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+    message: string;
+    retryable: boolean;
+    context?: Record<string, unknown> | undefined;
+    retryAfterMs?: number | undefined;
+}, {
+    code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+    message: string;
+    context?: Record<string, unknown> | undefined;
+    retryable?: boolean | undefined;
+    retryAfterMs?: number | undefined;
+}>;
+export type MCPStructuredError = z.infer<typeof MCPStructuredErrorSchema>;
+export declare const MCPResponseMetadataSchema: z.ZodObject<{
+    /** Operation duration in milliseconds */
+    durationMs: z.ZodNumber;
+    /** Whether result was served from cache */
+    cached: z.ZodDefault<z.ZodBoolean>;
+    /** Whether result was truncated due to size limits */
+    truncated: z.ZodDefault<z.ZodBoolean>;
+    /** Original size before truncation (if truncated) */
+    originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+    /** Request ID for tracing */
+    requestId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    truncated: boolean;
+    cached: boolean;
+    requestId?: string | undefined;
+    originalSizeBytes?: number | undefined;
+}, {
+    durationMs: number;
+    requestId?: string | undefined;
+    truncated?: boolean | undefined;
+    cached?: boolean | undefined;
+    originalSizeBytes?: number | undefined;
+}>;
+export type MCPResponseMetadata = z.infer<typeof MCPResponseMetadataSchema>;
+export declare const MCPSuccessResponseSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+export declare const MCPErrorResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        /** Error code for programmatic handling */
+        code: z.ZodEnum<["INVALID_INPUT", "MISSING_REQUIRED_FIELD", "INVALID_FORMAT", "ARRAY_TOO_LARGE", "STRING_TOO_LONG", "REQUEST_TOO_LARGE", "NOT_FOUND", "ALREADY_EXISTS", "CONFLICT", "OPERATION_FAILED", "TOOL_TIMEOUT", "RATE_LIMITED", "MEMORY_PRESSURE", "INTERNAL_ERROR", "NOT_IMPLEMENTED", "SERVICE_UNAVAILABLE"]>;
+        /** Human-readable message */
+        message: z.ZodString;
+        /** Additional context */
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Whether the operation can be retried */
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        /** Suggested retry delay in ms (if retryable) */
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        retryable: boolean;
+        context?: Record<string, unknown> | undefined;
+        retryAfterMs?: number | undefined;
+    }, {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        context?: Record<string, unknown> | undefined;
+        retryable?: boolean | undefined;
+        retryAfterMs?: number | undefined;
+    }>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        retryable: boolean;
+        context?: Record<string, unknown> | undefined;
+        retryAfterMs?: number | undefined;
+    };
+    success: false;
+    metadata?: {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    } | undefined;
+}, {
+    error: {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        context?: Record<string, unknown> | undefined;
+        retryable?: boolean | undefined;
+        retryAfterMs?: number | undefined;
+    };
+    success: false;
+    metadata?: {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    } | undefined;
+}>;
+export declare function createResponseEnvelopeSchema<T extends z.ZodTypeAny>(dataSchema: T): z.ZodDiscriminatedUnion<"success", [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        /** Error code for programmatic handling */
+        code: z.ZodEnum<["INVALID_INPUT", "MISSING_REQUIRED_FIELD", "INVALID_FORMAT", "ARRAY_TOO_LARGE", "STRING_TOO_LONG", "REQUEST_TOO_LARGE", "NOT_FOUND", "ALREADY_EXISTS", "CONFLICT", "OPERATION_FAILED", "TOOL_TIMEOUT", "RATE_LIMITED", "MEMORY_PRESSURE", "INTERNAL_ERROR", "NOT_IMPLEMENTED", "SERVICE_UNAVAILABLE"]>;
+        /** Human-readable message */
+        message: z.ZodString;
+        /** Additional context */
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Whether the operation can be retried */
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        /** Suggested retry delay in ms (if retryable) */
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        retryable: boolean;
+        context?: Record<string, unknown> | undefined;
+        retryAfterMs?: number | undefined;
+    }, {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        context?: Record<string, unknown> | undefined;
+        retryable?: boolean | undefined;
+        retryAfterMs?: number | undefined;
+    }>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Operation duration in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Whether result was served from cache */
+        cached: z.ZodDefault<z.ZodBoolean>;
+        /** Whether result was truncated due to size limits */
+        truncated: z.ZodDefault<z.ZodBoolean>;
+        /** Original size before truncation (if truncated) */
+        originalSizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Request ID for tracing */
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    }, {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        retryable: boolean;
+        context?: Record<string, unknown> | undefined;
+        retryAfterMs?: number | undefined;
+    };
+    success: false;
+    metadata?: {
+        durationMs: number;
+        truncated: boolean;
+        cached: boolean;
+        requestId?: string | undefined;
+        originalSizeBytes?: number | undefined;
+    } | undefined;
+}, {
+    error: {
+        code: "INVALID_INPUT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NOT_IMPLEMENTED" | "INVALID_FORMAT" | "MISSING_REQUIRED_FIELD" | "ARRAY_TOO_LARGE" | "STRING_TOO_LONG" | "REQUEST_TOO_LARGE" | "NOT_FOUND" | "ALREADY_EXISTS" | "CONFLICT" | "OPERATION_FAILED" | "TOOL_TIMEOUT" | "MEMORY_PRESSURE" | "SERVICE_UNAVAILABLE";
+        message: string;
+        context?: Record<string, unknown> | undefined;
+        retryable?: boolean | undefined;
+        retryAfterMs?: number | undefined;
+    };
+    success: false;
+    metadata?: {
+        durationMs: number;
+        requestId?: string | undefined;
+        truncated?: boolean | undefined;
+        cached?: boolean | undefined;
+        originalSizeBytes?: number | undefined;
+    } | undefined;
+}>]>;
+export declare const MCPPaginationSchema: z.ZodObject<{
+    /** Total count of all items */
+    total: z.ZodNumber;
+    /** Number of items requested */
+    limit: z.ZodNumber;
+    /** Offset from start */
+    offset: z.ZodNumber;
+    /** Whether more items exist */
+    hasMore: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    total: number;
+    hasMore: boolean;
+    offset: number;
+}, {
+    limit: number;
+    total: number;
+    hasMore: boolean;
+    offset: number;
+}>;
+export type MCPPagination = z.infer<typeof MCPPaginationSchema>;
+export declare function createListResponseSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+    items: z.ZodArray<T, "many">;
+    pagination: z.ZodObject<{
+        /** Total count of all items */
+        total: z.ZodNumber;
+        /** Number of items requested */
+        limit: z.ZodNumber;
+        /** Offset from start */
+        offset: z.ZodNumber;
+        /** Whether more items exist */
+        hasMore: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        total: number;
+        hasMore: boolean;
+        offset: number;
+    }, {
+        limit: number;
+        total: number;
+        hasMore: boolean;
+        offset: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    items: T["_output"][];
+    pagination: {
+        limit: number;
+        total: number;
+        hasMore: boolean;
+        offset: number;
+    };
+}, {
+    items: T["_input"][];
+    pagination: {
+        limit: number;
+        total: number;
+        hasMore: boolean;
+        offset: number;
+    };
+}>;
+export declare const MCPResponseLimitsSchema: z.ZodObject<{
+    /** Maximum response size in bytes */
+    maxResponseBytes: z.ZodDefault<z.ZodNumber>;
+    /** Maximum items in list responses */
+    maxListItems: z.ZodDefault<z.ZodNumber>;
+    /** Maximum string field length */
+    maxStringLength: z.ZodDefault<z.ZodNumber>;
+    /** Truncation indicator suffix */
+    truncationSuffix: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    maxResponseBytes: number;
+    maxListItems: number;
+    maxStringLength: number;
+    truncationSuffix: string;
+}, {
+    maxResponseBytes?: number | undefined;
+    maxListItems?: number | undefined;
+    maxStringLength?: number | undefined;
+    truncationSuffix?: string | undefined;
+}>;
+export type MCPResponseLimits = z.infer<typeof MCPResponseLimitsSchema>;
+export declare const DEFAULT_RESPONSE_LIMITS: MCPResponseLimits;
+//# sourceMappingURL=response.d.ts.map

package/dist/mcp/v1/runtime/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../src/mcp/v1/runtime/response.ts"],"names":[],"mappings":"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"}